using System;

using System.Collections;

using System.Collections.Generic;

using Mirror;

using UnityEngine;

using UnityEngine.Networking;

using Sniper;

​

/*

    Documentation: https://mirror-networking.gitbook.io/docs/components/network-authenticators

    API Reference: https://mirror-networking.com/docs/api/Mirror.NetworkAuthenticator.html

*/

​

public class UserNetworkAuthenticator : NetworkAuthenticator

{

    [SerializeField] private GameObject authRejectDialogPrefab;

    readonly HashSet<NetworkConnection> connectionsPendingDisconnect = new HashSet<NetworkConnection>();

    #region Messages

​

    public struct AuthRequestMessage : NetworkMessage {

        public string snid;

        public string accessToken;

    }

​

    public struct AuthResponseMessage : NetworkMessage {

        public bool success;

    }

​

    #endregion

​

    #region Server

​

    /// <summary>

    /// Called on server from StartServer to initialize the Authenticator

    /// <para>Server message handlers should be registered in this method.</para>

    /// </summary>

    public override void OnStartServer()

    {

        // register a handler for the authentication request we expect from client

        NetworkServer.RegisterHandler<AuthRequestMessage>(OnAuthRequestMessage, false);

    }

​

    /// <summary>

    /// Called on server from StopServer to reset the Authenticator

    /// <para>Server message handlers should be registered in this method.</para>

    /// </summary>

    public override void OnStopServer()

    {

        // unregister the handler for the authentication request

        NetworkServer.UnregisterHandler<AuthRequestMessage>();

    }

​

    /// <summary>

    /// Called on server from OnServerConnectInternal when a client needs to authenticate

    /// </summary>

    /// <param name="conn">Connection to client.</param>

    public override void OnServerAuthenticate(NetworkConnectionToClient conn) { }

​

    /// <summary>

    /// Called on server when the client's AuthRequestMessage arrives

    /// </summary>

    /// <param name="conn">Connection to client.</param>

    /// <param name="msg">The message payload</param>

    public void OnAuthRequestMessage(NetworkConnectionToClient conn, AuthRequestMessage msg)

    {

        if (connectionsPendingDisconnect.Contains(conn)) return;

​

        // get database of user and check the access token valid

        StartCoroutine(APIGetUser(msg.accessToken, (www) => {

            bool verify = www.result == UnityWebRequest.Result.Success;

​

            AuthResponseMessage authResponseMessage = new AuthResponseMessage { success = verify };

            conn.Send(authResponseMessage);

​

            if(verify) {

                // parse json data

                string jsonString = www.downloadHandler.text;

                User userData = JsonUtility.FromJson<User>(jsonString);

​

                // set user data to authentication data

                conn.authenticationData = userData;

​

                // Accept the successful authentication

                ServerAccept(conn);

​

                // remove multisession connections by snid

                List<NetworkConnectionToClient> connsToDisconnect = new List<NetworkConnectionToClient>();

                foreach(NetworkConnectionToClient currentConn in NetworkServer.connections.Values) {

                    if(currentConn == conn) {

                        continue;

                    }

                    User currentUser = (User)currentConn.authenticationData;

                    if(currentUser.snid == userData.snid) {

                        connsToDisconnect.Add(currentConn);

                    }

                }

                foreach(NetworkConnectionToClient currentConn in connsToDisconnect) {

                    currentConn.Disconnect();

                }

            }

            else {

                connectionsPendingDisconnect.Add(conn);

                // must set NetworkConnection isAuthenticated = false

                conn.isAuthenticated = false;

​

                // disconnect the client after 1 second so that response message gets delivered

                StartCoroutine(DelayedDisconnect(conn, 1f));

            }

        }));

​

    }

​

    IEnumerator APIGetUser(string accessToken, Action<UnityWebRequest> callback)

    {

        WWWForm form = new WWWForm();

        form.AddField("accessToken", accessToken);

        string url = Config.SCHEME + Config.CURRENT_DOMAIN + Config.API_ROUTE + "/users/getCurrentUserByAccessToken";

​

        using(UnityWebRequest www = UnityWebRequest.Post(url, form)) {

            yield return www.SendWebRequest();

            callback(www);

        }

    }

​

    IEnumerator DelayedDisconnect(NetworkConnectionToClient conn, float waitTime)

    {

        yield return new WaitForSeconds(waitTime);

​

        // Reject the unsuccessful authentication

        ServerReject(conn);

​

        yield return null;

​

        // remove conn from pending connections

        connectionsPendingDisconnect.Remove(conn);

    }

​

    #endregion

​

    #region Client

​

    /// <summary>

    /// Called on client from StartClient to initialize the Authenticator

    /// <para>Client message handlers should be registered in this method.</para>

    /// </summary>

    public override void OnStartClient()

    {

        // register a handler for the authentication response we expect from server

        NetworkClient.RegisterHandler<AuthResponseMessage>(OnAuthResponseMessage, false);

    }

​

    /// <summary>

    /// Called on client from StopClient to reset the Authenticator

    /// <para>Client message handlers should be unregistered in this method.</para>

    /// </summary>

    public override void OnStopClient()

    {

        // unregister the handler for the authentication response

        NetworkClient.UnregisterHandler<AuthResponseMessage>();

    }

​

    /// <summary>

    /// Called on client from OnClientConnectInternal when a client needs to authenticate

    /// </summary>

    public override void OnClientAuthenticate()

    {

        AuthRequestMessage authRequestMessage = new AuthRequestMessage {

            snid = CurrentUser.Value.snid,

            accessToken = CurrentUser.Value.accessToken

        };

​

        NetworkClient.Send(authRequestMessage);

    }

​

    /// <summary>

    /// Called on client when the server's AuthResponseMessage arrives

    /// </summary>

    /// <param name="msg">The message payload</param>

    public void OnAuthResponseMessage(AuthResponseMessage msg)

    {

        // Authentication has been accepted

        Debug.Log($"OnAuthResponseMessage {msg.success}");

        if(msg.success == true) {

            ClientAccept();

        }

        else {

            ClientReject();

            Instantiate(authRejectDialogPrefab);

        }

    }

​

    #endregion

}

​