using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Normal.Realtime.Native;
using Normal.Realtime.Serialization;

// Represents a room on the server. Manages the connection to the server and the data model.
namespace Normal.Realtime {
    public class Room {
        public delegate void ConnectionStateChanged(Room room, ConnectionState previousConnectionState, ConnectionState connectionState);
        public event ConnectionStateChanged connectionStateChanged;

        public delegate void RPCMessageReceived(Room room, byte[] data, bool reliable);
        public event RPCMessageReceived rpcMessageReceived;

        // Connection state
        public enum ConnectionState {
            Error                 = -1,
            Disconnected          = 0,
            ConnectingToMatcher   = 1,
            PingingRegions        = 2,
            FinishedMatching      = 3,
            ConnectingToRealtime  = 4,
            ConnectedToRealtime   = 5,
            Ready                 = 6, // Datastore is ready
        }
        private ConnectionState _connectionState = ConnectionState.Disconnected;
        public  ConnectionState  connectionState { get { return _connectionState; } }

        public bool connecting {
            get {
                return _connectionState == ConnectionState.ConnectingToMatcher  ||
                       _connectionState == ConnectionState.PingingRegions       ||
                       _connectionState == ConnectionState.FinishedMatching     ||
                       _connectionState == ConnectionState.ConnectingToRealtime ||
                       _connectionState == ConnectionState.ConnectedToRealtime;
            }
        }
        public bool connected       { get { return _connectionState == ConnectionState.Ready; } }
        public bool disconnected    { get { return _connectionState == ConnectionState.Disconnected || _connectionState == ConnectionState.Error; } }

        // Matcher
        private Matcher          _matcher;
        private List<PingResult> _pingResults;
        private int              _ipsLeftToPing = 0;
        private UInt64           _clientIdentifier;
        private byte[]           _connectToken;

        public int clientID { get { return !sessionCapturePlayback ? _client.ClientIndex() : 255; } }

        private double _time;
        public  double  time { get { return _time; } }

        // Datastore
        private Datastore _datastore;
        public  Datastore  datastore { get { return _datastore; } }

        public  double  datastoreFrameDuration = 1.0/20.0;
        private double _deltaTime;
        private uint   _nextUpdateID = 1; // TODO: Convert to zero when 0 isn't used to signal the initial state of the room

        // Native API
        private Client _client;

        // Realtime
        private Realtime _realtime;
        public  Realtime  realtime { get { return _realtime; } }

        private IModel _roomModel;

        // Debug
        private bool _debugLogging = false;
        public  bool  debugLogging { get { return _debugLogging; } set { if (value == _debugLogging) return; Plugin.logLevel = value ? Plugin.LogLevel.LogLevelInfo : Plugin.LogLevel.LogLevelError; _debugLogging = value; } }

        // Session capture / playback
        private SessionCapture _sessionCapture;
        private bool            sessionCaptureRecord   { get { return _sessionCapture != null && _sessionCapture.mode == SessionCapture.Mode.Record; } }
        private bool            sessionCapturePlayback { get { return _sessionCapture != null && _sessionCapture.mode == SessionCapture.Mode.Playback; } }

        public Room() : this(null) {

        }

        public Room(SessionCapture sessionCapture) {
            _sessionCapture = sessionCapture;

            _deltaTime = 0.0;

            _datastore = new Datastore();
            
            if (!sessionCapturePlayback) {
                _client = new Client();
                _client.persistenceMessageReceived += ReceivedPersistenceMessage;
                _client.rpcMessageReceived         += ReceivedRPCMessage;
            }
        }

        ~Room() {
            if (_client != null) {
                _client.persistenceMessageReceived -= ReceivedPersistenceMessage;
                _client.rpcMessageReceived         -= ReceivedRPCMessage;
                _client.Dispose();
            }

            DisposeMatcher();
        }

        // State
        private void SetConnectionState(ConnectionState connectionState) {
            if (connectionState == _connectionState)
                return;

            ConnectionState previousConnectionState = _connectionState;

            _connectionState = connectionState;

            if (connectionStateChanged != null) {
                try {
                    connectionStateChanged(this, previousConnectionState, connectionState);
                } catch (Exception exception) {
                    Debug.LogException(exception);
                }
            }

            switch (connectionState) {
                case ConnectionState.Error:
                    // Stop recording
                    if (sessionCaptureRecord)
                        _sessionCapture.StopRecording();

                    // Clear datastore
                    _datastore.Reset(null);

                    Debug.LogError("Realtime: Connection failed" + (!_debugLogging ? ". Turn on debug logging for more details." : ""));
                    break;
                case ConnectionState.Disconnected:
                    // Stop recording
                    if (sessionCaptureRecord)
                        _sessionCapture.StopRecording();

                    // Clear datastore
                    _datastore.Reset(null);

                    Debug.Log("Realtime: Disconnected");
                    break;
                case ConnectionState.ConnectingToMatcher:
                    if (_debugLogging)
                        Debug.Log("Realtime: Connecting to matcher.");
                    break;
                case ConnectionState.FinishedMatching:
                    // Reset datastore
                    _datastore.Reset(_roomModel);

                    // Set state to connecting to realtime
                    SetConnectionState(ConnectionState.ConnectingToRealtime);
                    _client.Connect(_clientIdentifier, _connectToken);
                    break;
                case ConnectionState.Ready:
                    Debug.Log("Realtime: Connected");
                    break;
                case ConnectionState.PingingRegions:
                    Debug.Log("Realtime: Pinging regions to determine server with lowest latency for this client.");
                    string[] IPsToPing = _matcher.GetIPsToPing();
                    PingServers(IPsToPing);
                    break;
            }
        }

        // Realtime
        public void _SetRealtime(Realtime realtime) {
            _realtime = realtime;
        }

        // Network Statistics
        public NetworkInfo GetNetworkStatistics() {
            if (_client == null)
                return new NetworkInfo();

            return _client.GetNetworkStatistics();
        }

        // Connect / Disconnect
        public void Connect(string roomName, string appKey, IModel roomModel = null) {
            if (!sessionCapturePlayback) {
                ConnectToServer(roomName, appKey, roomModel);
            } else {
                Debug.Log("Realtime: Connect() called on Room with session capture override. Will begin playing back session capture now.");
                StartSessonCapturePlayback(roomModel);
            }
        }

        private void ConnectToServer(string roomName, string appKey, IModel roomModel = null) {
            if (connectionState != ConnectionState.Disconnected && connectionState != ConnectionState.Error) {
                Debug.LogError("Room asked to connect to server, but room is already connecting or connected (" + connectionState + "). Ignoring.");
                return;
            }
            
            Debug.Log("Realtime: Connecting to room \"" + roomName + "\"");

            SetConnectionState(ConnectionState.ConnectingToMatcher);

            _roomModel = roomModel;

            _clientIdentifier = Client.GenerateSecureClientIdentifier();

            // Begin connecting to the matcher
            JoinRoom(roomName, appKey, _clientIdentifier);
        }

        private void StartSessonCapturePlayback(IModel roomModel = null) {
            // Reset datastore
            _datastore.Reset(roomModel);

            // Fire connecting / connected to Realtime events
            SetConnectionState(ConnectionState.ConnectingToRealtime);
            SetConnectionState(ConnectionState.ConnectedToRealtime);

            // Start session capture playback
            byte[] initialDatastore = _sessionCapture.StartPlayback();

            // Initialize datastore
            _datastore.Deserialize(initialDatastore);

            // Reset _deltaTime
            _deltaTime = 0.0;

            // We're ready!
            SetConnectionState(ConnectionState.Ready);
        }

        public void Disconnect() {
            Disconnect(false);
        }

        private void Disconnect(bool error) {
            // Disconnect client
            if (_client != null)
                _client.Disconnect();

            DisposeMatcher();

            // Stop session capture / playback
            if (_sessionCapture != null) {
                _sessionCapture.StopRecording();
                _sessionCapture.StopPlayback();
            }

            // Set connection state
            if (error)
                SetConnectionState(ConnectionState.Error);
            else
                SetConnectionState(ConnectionState.Disconnected);
        }

        // Tick
        public void Tick(double deltaTime) {
            if (!sessionCapturePlayback)
                RoomTick(deltaTime);
            else
                PlaybackTick(deltaTime);
        }

        private void RoomTick(double deltaTime) {
            // Connect to a room on the Matcher if needed.
            MatcherTick();

            // Info
            // We grab time here because we want to have the same timestamp on deserialize/serialize operations called by ClienTick()/PersistenceTick().
            _time = _client.RoomTime();

            // Process incoming network packets and send out anything that's been sitting around.
            // TODO: Given that this is going to send/receive packets all at once. Maybe we should call Tick twice? Call it once here to receive packets + dispatch messages, and again at the end to send them right away.
            // TODO: We can't do the above TODO until _client.Tick() does its own delta time calculation
            ClientTick();

            // Persistence
            PersistenceTick(deltaTime);
        }

        private void MatcherTick() {
            if (_matcher == null)
                return;

            int matcherState = _matcher.Tick();

            switch (matcherState) {
                case (int)Matcher.State.ReadyToPingRegions:
                    SetConnectionState(ConnectionState.PingingRegions);
                    break;

                case (int)Matcher.State.Disconnected:
                    if (_debugLogging)
                        Debug.LogError("Realtime: The matcher has disconnected.");
                    SetConnectionState(ConnectionState.Disconnected);
                    DisposeMatcher();
                    break;
                case (int)Matcher.State.Done:
                    _connectToken = _matcher.GetConnectToken();
                    DisposeMatcher();
                    SetConnectionState(ConnectionState.FinishedMatching);
                    break;
                case (int)Matcher.State.Error:
                    Debug.LogError("Realtime: There was an issue connecting to a room on the matcher. (" + _matcher.GetServerError() + ")");
                    SetConnectionState(ConnectionState.Error);
                    DisposeMatcher();
                    break;
                default:
                    break;
            }
        }

        // Matcher
        /// <summary>
        ///  Join a realtime room. If one with the given roomID is not currently running, it will ping
        ///  servers around the world to find the closest region to start up a new room.
        /// <param name="roomID">The UUID of a room to join.</param>
        /// <param name="appKey">Normal Developer App Key.</param>
        /// <param name="clientIdentifier">Secure random UInt64 used to identify this client</param>
        /// </summary>
        private void JoinRoom(string roomID, string appKey, UInt64 clientIdentifier) {
            if (_matcher != null) {
                DisposeMatcher();
            }

            SetConnectionState(ConnectionState.ConnectingToMatcher);
            _matcher = new Matcher();
            _matcher.Connect(roomID, appKey, clientIdentifier);
        }

        /// <summary>
        /// Ping an array of IPs and return the IP with the lowest ping time.
        /// <param name="servers">An array of IP strings.</param>
        /// </summary>
        private void PingServers(string[] servers) {
            SetConnectionState(ConnectionState.PingingRegions);
            _pingResults = new List<PingResult>();
            _ipsLeftToPing = servers.Length;

            foreach (string ip in servers) {
                _realtime.StartCoroutine(StartPing(ip));
            }
        }

        /// <summary>
        ///   Starts a new ping operation for a given IP.
        /// </summary>
        IEnumerator StartPing(string address) {
            Ping ping = new Ping(address);
            float startTime = Time.realtimeSinceStartup;

            // Wait for up to 8 seconds for the ping to finish.
            while (!ping.isDone && (Time.realtimeSinceStartup - startTime) < 8.0f) {
                yield return null;
            }

            PingFinished(ping);
        }

        /// <summary>
        /// Each ping will call this when it's done or has failed. When we have all the pings
        /// we call the completion handler with the ping with the lowest time.
        /// <param name="p">The ping that just completed.</param>
        /// </summary>
        private void PingFinished(Ping p) {
            PingResult pr = new PingResult(p.ip, p.time);
            _pingResults.Add(pr);

            // Log an error if a ping failed, but we need to respond to the matcher with the time regardless, which will be -1.
            if (!p.isDone && _debugLogging) {
                Debug.LogError(string.Format("Ping failed for address: {0} with ping time: {1}", p.ip, p.time));
            }

            _ipsLeftToPing--;

            if (_ipsLeftToPing <= 0) {
                foreach (PingResult sPing in _pingResults) {
                    if (_debugLogging)
                        Debug.Log(string.Format("Realtime: IP: {0} Ping Time: {1}", sPing.address, sPing.time));
                }

                if (_debugLogging && (_connectionState != ConnectionState.PingingRegions || _matcher == null)) {
                    Debug.LogWarning("Realtime: Yo, Jeff here. If you see this log, lmk, you can safely ignore it, but I want to know what's happening. The client (" + _clientIdentifier + ") sent back ping results in the state (" + connectionState + ") which was not PingingRegions.");
                } else {
                    _matcher.ContinueConnectionWithPingTimes(_pingResults.ToArray());
                }
            }
        }

        private void ClientTick() {
            if (connectionState != ConnectionState.ConnectingToRealtime &&
                connectionState != ConnectionState.ConnectedToRealtime  &&
                connectionState != ConnectionState.Ready)
                return;

            int clientConnectionState = _client.Tick();

            // Update connection state using native client
            switch (clientConnectionState) {
                case -1: // Error
                    SetConnectionState(ConnectionState.Error);
                    break;
                case 0: // Disconnected
                    SetConnectionState(ConnectionState.Disconnected);
                    break;
                case 1: // Connecting
                    SetConnectionState(ConnectionState.ConnectingToRealtime);
                    break;
                case 2: // Connected
                    if (connectionState == ConnectionState.ConnectingToRealtime)
                        SetConnectionState(ConnectionState.ConnectedToRealtime);
                    break;
                default:
                    Debug.LogError("NativeClient returned unknown client state: " + clientConnectionState + ". This is a bug.");
                    break;
            }
        }

        // Persistence
        private void PersistenceTick(double deltaTime) {
            // Wait until we're in sync with the server
            if (_connectionState != ConnectionState.Ready)
                return;

            _deltaTime += deltaTime;
            if (_deltaTime >= datastoreFrameDuration) {
                _deltaTime -= datastoreFrameDuration;

                try {
                    WriteBuffer writeBuffer = _datastore.writeBuffer;

                    // Unreliable
                    _datastore.SerializeDeltaUpdates(false);
                    if (writeBuffer.bytesWritten > 0) {
                        _client.SendPersistenceMessage(writeBuffer.GetBuffer(), writeBuffer.bytesWritten, false);

                        // Record delta update if local session capture is enabled and set to record
                        if (sessionCaptureRecord)
                            _sessionCapture.WriteDeltaUpdate(_time, clientID, writeBuffer.GetBuffer(), writeBuffer.bytesWritten, false, 0, false);
                    }

                    // Reliable
                    _datastore.SerializeDeltaUpdates(true, _nextUpdateID);
                    if (writeBuffer.bytesWritten > 0) {
                        _client.SendPersistenceMessage(writeBuffer.GetBuffer(), writeBuffer.bytesWritten, true);

                        // Record delta update if local session capture is enabled and set to record
                        if (sessionCaptureRecord)
                            _sessionCapture.WriteDeltaUpdate(_time, clientID, writeBuffer.GetBuffer(), writeBuffer.bytesWritten, true, _nextUpdateID, false);

                        // Only increment if data was written
                        _nextUpdateID++;
                    }
                } catch (Exception exception) {
                    Debug.LogException(exception);
                    Debug.LogError("Failed to serialize datastore message. Disconnecting.");
                    Disconnect(true);
                }
            }
        }

        void ReceivedPersistenceMessage(Client client, int sender, byte[] data, bool reliable) {
            if (connectionState != ConnectionState.ConnectingToRealtime &&
                connectionState != ConnectionState.ConnectedToRealtime  &&
                connectionState != ConnectionState.Ready) {
                Debug.LogError("Room received persistence message while not in a connection state where it would be expecting one (" + connectionState + "). This is a bug! Ignoring.");
                return;
            }

            bool updateIsFromUs = sender == clientID;

            // TODO: We need to add try catches around all native -> managed callbacks (ideally in Plugin.cs or Client.cs if we have to). If C# throws an exception, it skips the native code that runs too which can lead to leaks.
            bool isInitialRoomMessage = connectionState != ConnectionState.Ready;
            try {
                // If we're not in a ready state, try to initialize the datastore with this message.
                if (connectionState != ConnectionState.Ready) {
                    // Make sure we didn't accidentally receive an unreliable update that arrived out of order from the original room setup message...
                    if (reliable) {
                        // Retrieve the room time now that the client has calculated it
                        _time = _client.RoomTime();

                        // Initialize datastore
                        _datastore.Deserialize(data);

                        // Reset _deltaTime
                        _deltaTime = 0.0;

                        // We're ready!
                        SetConnectionState(ConnectionState.Ready);

                        // Start session capture if local session capture is enabled and set to record
                        if (sessionCaptureRecord)
                            _sessionCapture.StartRecording(clientID, time, data);
                    }
                } else {
                    // Apply delta update to the datastore
                    uint updateID = _datastore.DeserializeDeltaUpdates(data, reliable, updateIsFromUs);

                    // Record delta update if local session capture is enabled and set to record
                    if (sessionCaptureRecord)
                        _sessionCapture.WriteDeltaUpdate(_time, sender, data, data.Length, reliable, updateID, true);
                }
            } catch (Exception e) {
                bool readUpdateID = reliable;
                if (isInitialRoomMessage)
                    readUpdateID = false;

                Debug.LogException(e);
                BufferAnalyzer bufferAnalyzer = new BufferAnalyzer();
                Debug.LogError("Failed to deserialize incoming datastore message. Disconnecting. (" + isInitialRoomMessage + ") (" + reliable + "): " + bufferAnalyzer.AnalyzeBuffer(new ReadBuffer(data), readUpdateID));
                Disconnect(true);
            }
        }

        private void PlaybackTick(double deltaTime) {
            if (!_sessionCapture.playing)
                return;

            // Tick
            _sessionCapture.PlaybackTick(deltaTime);

            // Read updates until we've read up to the current playback time
            SessionCapture.DeltaUpdate deltaUpdate = _sessionCapture.ReadDeltaUpdate();
            while (deltaUpdate != null) {
                // Update room time
                _time = deltaUpdate.timestamp;

                // Apply delta update
                if (deltaUpdate.data.Length > 0)
                    _datastore.DeserializeDeltaUpdates(deltaUpdate.data, deltaUpdate.reliable, false);

                // Read next update
                deltaUpdate = _sessionCapture.ReadDeltaUpdate();
            }

            if (!_sessionCapture.playing)
                SetConnectionState(ConnectionState.Disconnected);
        }

        private void DisposeMatcher() {
            if (_matcher != null) {
                if (_debugLogging)
                    Debug.Log("Disposing Matcher.");

                _matcher.Dispose();
                _matcher = null;
            }
        }

        // RPC
        public bool SendRPCMessage(byte[] data, bool reliable) {
            return _client.SendRPCMessage(data, data.Length, reliable);
        }

        public bool SendRPCMessage(byte[] data, int dataLength, bool reliable) {
            return _client.SendRPCMessage(data, dataLength, reliable);
        }

        private void ReceivedRPCMessage(Client client, byte[] data, bool reliable) {
            try {
                if (rpcMessageReceived != null)
                    rpcMessageReceived(this, data, reliable);
            } catch (Exception exception) {
                Debug.LogException(exception);
            }
        }

        // Audio
        public AudioInputStream CreateAudioInputStream(bool voice, int sampleRate, int channels) {
            if (sessionCapturePlayback)
                return null; // TODO: Implement audio stream support

            return _client.CreateAudioInputStream(voice, sampleRate, channels);
        }

        public AudioOutputStream GetAudioOutputStream(int clientID, int streamID) {
            if (sessionCapturePlayback)
                return null; // TODO: Implement audio stream support

            return _client.GetAudioOutputStream(clientID, streamID);
        }
    }
}