// Decompiled with JetBrains decompiler
// Type: Terraria.Netplay
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Terraria.Audio;
using Terraria.IO;
using Terraria.Localization;
using Terraria.Map;
using Terraria.Net;
using Terraria.Net.Sockets;
using Terraria.Social;
using Terraria.Utilities;

namespace Terraria
{
  public class Netplay
  {
    public const int MaxConnections = 256;
    public const int NetBufferSize = 1024;
    public static string BanFilePath = "banlist.txt";
    public static string ServerPassword = "";
    public static RemoteClient[] Clients = new RemoteClient[256];
    public static RemoteServer Connection = new RemoteServer();
    public static IPAddress ServerIP;
    public static string ServerIPText = "";
    public static ISocket TcpListener;
    public static int ListenPort = 7777;
    public static bool IsListening = true;
    public static bool UseUPNP = true;
    public static bool Disconnect;
    public static bool SpamCheck = false;
    public static bool HasClients;
    private static Thread _serverThread;
    public static MessageBuffer fullBuffer = new MessageBuffer();
    private static int _currentRequestId;
    private static UdpClient BroadcastClient = (UdpClient) null;
    private static Thread broadcastThread = (Thread) null;

    public static event Action OnDisconnect;

    private static void UpdateServer()
    {
      for (int bufferIndex = 0; bufferIndex < 256; ++bufferIndex)
      {
        if (NetMessage.buffer[bufferIndex].checkBytes)
          NetMessage.CheckBytes(bufferIndex);
      }
    }

    private static string GetLocalIPAddress()
    {
      string str = "";
      foreach (IPAddress address in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
      {
        if (address.AddressFamily == AddressFamily.InterNetwork)
        {
          str = address.ToString();
          break;
        }
      }
      return str;
    }

    private static void ResetNetDiag() => Main.ActiveNetDiagnosticsUI.Reset();

    public static void ResetSections()
    {
      for (int index1 = 0; index1 < 256; ++index1)
      {
        for (int index2 = 0; index2 < Main.maxSectionsX; ++index2)
        {
          for (int index3 = 0; index3 < Main.maxSectionsY; ++index3)
            Netplay.Clients[index1].TileSections[index2, index3] = false;
        }
      }
    }

    public static void AddBan(int plr)
    {
      RemoteAddress remoteAddress = Netplay.Clients[plr].Socket.GetRemoteAddress();
      using (StreamWriter streamWriter = new StreamWriter(Netplay.BanFilePath, true))
      {
        streamWriter.WriteLine("//" + Main.player[plr].name);
        streamWriter.WriteLine(remoteAddress.GetIdentifier());
      }
    }

    public static bool IsBanned(RemoteAddress address)
    {
      try
      {
        string identifier = address.GetIdentifier();
        if (System.IO.File.Exists(Netplay.BanFilePath))
        {
          using (StreamReader streamReader = new StreamReader(Netplay.BanFilePath))
          {
            string str;
            while ((str = streamReader.ReadLine()) != null)
            {
              if (str == identifier)
                return true;
            }
          }
        }
      }
      catch (Exception ex)
      {
      }
      return false;
    }

    private static void OpenPort(int port)
    {
    }

    private static void ClosePort(int port)
    {
    }

    private static void ServerFullWriteCallBack(object state)
    {
    }

    private static void OnConnectionAccepted(ISocket client)
    {
      int nextOpenClientSlot = Netplay.FindNextOpenClientSlot();
      if (nextOpenClientSlot != -1)
      {
        Netplay.Clients[nextOpenClientSlot].Reset();
        Netplay.Clients[nextOpenClientSlot].Socket = client;
      }
      else
      {
        lock (Netplay.fullBuffer)
          Netplay.KickClient(client, NetworkText.FromKey("CLI.ServerIsFull"));
      }
      if (Netplay.FindNextOpenClientSlot() != -1)
        return;
      Netplay.StopListening();
      Netplay.IsListening = false;
    }

    private static void KickClient(ISocket client, NetworkText kickMessage)
    {
      BinaryWriter writer = Netplay.fullBuffer.writer;
      if (writer == null)
      {
        Netplay.fullBuffer.ResetWriter();
        writer = Netplay.fullBuffer.writer;
      }
      writer.BaseStream.Position = 0L;
      long position1 = writer.BaseStream.Position;
      writer.BaseStream.Position += 2L;
      writer.Write((byte) 2);
      kickMessage.Serialize(writer);
      if (Main.dedServ)
        Console.WriteLine(Language.GetTextValue("CLI.ClientWasBooted", (object) client.GetRemoteAddress().ToString(), (object) kickMessage));
      int position2 = (int) writer.BaseStream.Position;
      writer.BaseStream.Position = position1;
      writer.Write((short) position2);
      writer.BaseStream.Position = (long) position2;
      client.AsyncSend(Netplay.fullBuffer.writeBuffer, 0, position2, new SocketSendCallback(Netplay.ServerFullWriteCallBack), (object) client);
    }

    public static void OnConnectedToSocialServer(ISocket client) => Netplay.StartSocialClient(client);

    private static bool StartListening()
    {
      if (SocialAPI.Network != null)
        SocialAPI.Network.StartListening(new SocketConnectionAccepted(Netplay.OnConnectionAccepted));
      return Netplay.TcpListener.StartListening(new SocketConnectionAccepted(Netplay.OnConnectionAccepted));
    }

    private static void StopListening()
    {
      if (SocialAPI.Network != null)
        SocialAPI.Network.StopListening();
      Netplay.TcpListener.StopListening();
    }

    public static void StartServer()
    {
      Netplay.InitializeServer();
      Netplay._serverThread = new Thread(new ThreadStart(Netplay.ServerLoop))
      {
        IsBackground = true,
        Name = "Server Loop Thread"
      };
      Netplay._serverThread.Start();
    }

    private static void InitializeServer()
    {
      Netplay.ResetNetDiag();
      if (Main.rand == null)
        Main.rand = new UnifiedRandom((int) DateTime.Now.Ticks);
      Main.myPlayer = (int) byte.MaxValue;
      Netplay.ServerIP = IPAddress.Any;
      Main.menuMode = 14;
      Main.statusText = Lang.menu[8].Value;
      Main.netMode = 2;
      Netplay.Disconnect = false;
      for (int index = 0; index < 256; ++index)
      {
        Netplay.Clients[index] = new RemoteClient();
        Netplay.Clients[index].Reset();
        Netplay.Clients[index].Id = index;
        Netplay.Clients[index].ReadBuffer = new byte[1024];
      }
      Netplay.TcpListener = (ISocket) new TcpSocket();
      if (!Netplay.Disconnect)
      {
        if (!Netplay.StartListening())
        {
          Main.menuMode = 15;
          Main.statusText = Language.GetTextValue("Error.TriedToRunServerTwice");
          Netplay.Disconnect = true;
        }
        Main.statusText = Language.GetTextValue("CLI.ServerStarted");
      }
      if (!Netplay.UseUPNP)
        return;
      try
      {
        Netplay.OpenPort(Netplay.ListenPort);
      }
      catch (Exception ex)
      {
      }
    }

    private static void CleanupServer()
    {
      Netplay.StopListening();
      try
      {
        Netplay.ClosePort(Netplay.ListenPort);
      }
      catch
      {
      }
      for (int index = 0; index < 256; ++index)
        Netplay.Clients[index].Reset();
      if (Main.menuMode != 15)
      {
        Main.netMode = 0;
        Main.menuMode = 10;
        WorldFile.SaveWorld();
        Main.menuMode = 0;
      }
      else
        Main.netMode = 0;
      Main.myPlayer = 0;
    }

    private static void ServerLoop()
    {
      int num = 0;
      Netplay.StartBroadCasting();
      while (!Netplay.Disconnect)
      {
        Netplay.StartListeningIfNeeded();
        Netplay.UpdateConnectedClients();
        num = (num + 1) % 10;
        Thread.Sleep(num == 0 ? 1 : 0);
      }
      Netplay.StopBroadCasting();
      Netplay.CleanupServer();
    }

    private static void UpdateConnectedClients()
    {
      int num1 = 0;
      for (int index = 0; index < 256; ++index)
      {
        if (Netplay.Clients[index].PendingTermination)
        {
          if (Netplay.Clients[index].PendingTerminationApproved)
          {
            Netplay.Clients[index].Reset();
            NetMessage.SyncDisconnectedPlayer(index);
          }
        }
        else if (Netplay.Clients[index].IsConnected())
        {
          Netplay.Clients[index].Update();
          ++num1;
        }
        else if (Netplay.Clients[index].IsActive)
        {
          Netplay.Clients[index].PendingTermination = true;
          Netplay.Clients[index].PendingTerminationApproved = true;
        }
        else
        {
          Netplay.Clients[index].StatusText2 = "";
          if (index < (int) byte.MaxValue)
          {
            int num2 = Main.player[index].active ? 1 : 0;
            Main.player[index].active = false;
            if (num2 != 0)
              Player.Hooks.PlayerDisconnect(index);
          }
        }
      }
      Netplay.HasClients = (uint) num1 > 0U;
    }

    private static void StartListeningIfNeeded()
    {
      if (Netplay.IsListening)
        return;
      if (!((IEnumerable<RemoteClient>) Netplay.Clients).Any<RemoteClient>((Func<RemoteClient, bool>) (client => !client.IsConnected())))
        return;
      try
      {
        Netplay.StartListening();
        Netplay.IsListening = true;
      }
      catch
      {
        if (Main.ignoreErrors)
          return;
        throw;
      }
    }

    private static void UpdateClient()
    {
      if (Main.netMode != 1 || !Netplay.Connection.Socket.IsConnected() || !NetMessage.buffer[256].checkBytes)
        return;
      NetMessage.CheckBytes();
    }

    public static void AddCurrentServerToRecentList()
    {
      if (Netplay.Connection.Socket.GetRemoteAddress().Type != AddressType.Tcp)
        return;
      for (int index1 = 0; index1 < Main.maxMP; ++index1)
      {
        if (Main.recentIP[index1].ToLower() == Netplay.ServerIPText.ToLower() && Main.recentPort[index1] == Netplay.ListenPort)
        {
          for (int index2 = index1; index2 < Main.maxMP - 1; ++index2)
          {
            Main.recentIP[index2] = Main.recentIP[index2 + 1];
            Main.recentPort[index2] = Main.recentPort[index2 + 1];
            Main.recentWorld[index2] = Main.recentWorld[index2 + 1];
          }
        }
      }
      for (int index = Main.maxMP - 1; index > 0; --index)
      {
        Main.recentIP[index] = Main.recentIP[index - 1];
        Main.recentPort[index] = Main.recentPort[index - 1];
        Main.recentWorld[index] = Main.recentWorld[index - 1];
      }
      Main.recentIP[0] = Netplay.ServerIPText;
      Main.recentPort[0] = Netplay.ListenPort;
      Main.recentWorld[0] = Main.worldName;
      Main.SaveRecent();
    }

    public static void SocialClientLoop(object threadContext)
    {
      ISocket socket = (ISocket) threadContext;
      Netplay.ClientLoopSetup(socket.GetRemoteAddress());
      Netplay.Connection.Socket = socket;
      Netplay.InnerClientLoop();
    }

    public static void TcpClientLoop()
    {
      Netplay.ClientLoopSetup((RemoteAddress) new TcpAddress(Netplay.ServerIP, Netplay.ListenPort));
      Main.menuMode = 14;
      bool flag = true;
      while (flag)
      {
        flag = false;
        try
        {
          Netplay.Connection.Socket.Connect((RemoteAddress) new TcpAddress(Netplay.ServerIP, Netplay.ListenPort));
          flag = false;
        }
        catch
        {
          if (!Netplay.Disconnect)
          {
            if (Main.gameMenu)
              flag = true;
          }
        }
      }
      Netplay.InnerClientLoop();
    }

    private static void ClientLoopSetup(RemoteAddress address)
    {
      Netplay.ResetNetDiag();
      Main.ServerSideCharacter = false;
      if (Main.rand == null)
        Main.rand = new UnifiedRandom((int) DateTime.Now.Ticks);
      Main.player[Main.myPlayer].hostile = false;
      Main.clientPlayer = (Player) Main.player[Main.myPlayer].clientClone();
      for (int index = 0; index < (int) byte.MaxValue; ++index)
      {
        if (index != Main.myPlayer)
          Main.player[index] = new Player();
      }
      Main.netMode = 1;
      Main.menuMode = 14;
      if (!Main.autoPass)
        Main.statusText = Language.GetTextValue("Net.ConnectingTo", (object) address.GetFriendlyName());
      Netplay.Disconnect = false;
      Netplay.Connection = new RemoteServer();
      Netplay.Connection.ReadBuffer = new byte[1024];
    }

    private static void InnerClientLoop()
    {
      try
      {
        NetMessage.buffer[256].Reset();
        int num1 = -1;
        while (!Netplay.Disconnect)
        {
          if (Netplay.Connection.Socket.IsConnected())
          {
            Netplay.Connection.IsActive = true;
            if (Netplay.Connection.State == 0)
            {
              Main.statusText = Language.GetTextValue("Net.FoundServer");
              Netplay.Connection.State = 1;
              NetMessage.SendData(1);
            }
            if (Netplay.Connection.State == 2 && num1 != Netplay.Connection.State)
              Main.statusText = Language.GetTextValue("Net.SendingPlayerData");
            if (Netplay.Connection.State == 3 && num1 != Netplay.Connection.State)
              Main.statusText = Language.GetTextValue("Net.RequestingWorldInformation");
            if (Netplay.Connection.State == 4)
            {
              WorldGen.worldCleared = false;
              Netplay.Connection.State = 5;
              Main.cloudBGAlpha = (double) Main.cloudBGActive < 1.0 ? 0.0f : 1f;
              Main.windSpeedCurrent = Main.windSpeedTarget;
              Cloud.resetClouds();
              Main.cloudAlpha = Main.maxRaining;
              WorldGen.clearWorld();
              if (Main.mapEnabled)
                Main.Map.Load();
            }
            if (Netplay.Connection.State == 5 && Main.loadMapLock)
            {
              float num2 = (float) Main.loadMapLastX / (float) Main.maxTilesX;
              Main.statusText = Lang.gen[68].Value + " " + (object) (int) ((double) num2 * 100.0 + 1.0) + "%";
            }
            else if (Netplay.Connection.State == 5 && WorldGen.worldCleared)
            {
              Netplay.Connection.State = 6;
              Main.player[Main.myPlayer].FindSpawn();
              NetMessage.SendData(8, number: Main.player[Main.myPlayer].SpawnX, number2: ((float) Main.player[Main.myPlayer].SpawnY));
            }
            if (Netplay.Connection.State == 6 && num1 != Netplay.Connection.State)
              Main.statusText = Language.GetTextValue("Net.RequestingTileData");
            if (!Netplay.Connection.IsReading && !Netplay.Disconnect && Netplay.Connection.Socket.IsDataAvailable())
            {
              Netplay.Connection.IsReading = true;
              Netplay.Connection.Socket.AsyncReceive(Netplay.Connection.ReadBuffer, 0, Netplay.Connection.ReadBuffer.Length, new SocketReceiveCallback(Netplay.Connection.ClientReadCallBack));
            }
            if (Netplay.Connection.StatusMax > 0 && Netplay.Connection.StatusText != "")
            {
              if (Netplay.Connection.StatusCount >= Netplay.Connection.StatusMax)
              {
                Main.statusText = Language.GetTextValue("Net.StatusComplete", (object) Netplay.Connection.StatusText);
                Netplay.Connection.StatusText = "";
                Netplay.Connection.StatusMax = 0;
                Netplay.Connection.StatusCount = 0;
              }
              else
                Main.statusText = Netplay.Connection.StatusText + ": " + (object) (int) ((double) Netplay.Connection.StatusCount / (double) Netplay.Connection.StatusMax * 100.0) + "%";
            }
            Thread.Sleep(1);
          }
          else if (Netplay.Connection.IsActive)
          {
            Main.statusText = Language.GetTextValue("Net.LostConnection");
            Netplay.Disconnect = true;
          }
          num1 = Netplay.Connection.State;
        }
        try
        {
          Netplay.Connection.Socket.Close();
        }
        catch
        {
        }
        if (!Main.gameMenu)
        {
          Main.gameMenu = true;
          Main.SwitchNetMode(0);
          MapHelper.noStatusText = true;
          Player.SavePlayer(Main.ActivePlayerFileData);
          Player.ClearPlayerTempInfo();
          Main.ActivePlayerFileData.StopPlayTimer();
          SoundEngine.StopTrackedSounds();
          MapHelper.noStatusText = false;
          Main.menuMode = 14;
        }
        NetMessage.buffer[256].Reset();
        if (Main.menuMode == 15 && Main.statusText == Language.GetTextValue("Net.LostConnection"))
          Main.menuMode = 14;
        if (Netplay.Connection.StatusText != "" && Netplay.Connection.StatusText != null)
          Main.statusText = Language.GetTextValue("Net.LostConnection");
        Netplay.Connection.StatusCount = 0;
        Netplay.Connection.StatusMax = 0;
        Netplay.Connection.StatusText = "";
        Main.SwitchNetMode(0);
      }
      catch (Exception ex)
      {
        try
        {
          using (StreamWriter streamWriter = new StreamWriter("client-crashlog.txt", true))
          {
            streamWriter.WriteLine((object) DateTime.Now);
            streamWriter.WriteLine((object) ex);
            streamWriter.WriteLine("");
          }
        }
        catch
        {
        }
        Netplay.Disconnect = true;
      }
      if (Netplay.OnDisconnect == null)
        return;
      Netplay.OnDisconnect();
    }

    private static int FindNextOpenClientSlot()
    {
      for (int index = 0; index < Main.maxNetPlayers; ++index)
      {
        if (!Netplay.Clients[index].IsConnected())
          return index;
      }
      return -1;
    }

    public static void StartSocialClient(ISocket socket) => new Thread(new ParameterizedThreadStart(Netplay.SocialClientLoop))
    {
      Name = "Social Client Thread",
      IsBackground = true
    }.Start((object) socket);

    public static void StartTcpClient() => new Thread(new ThreadStart(Netplay.TcpClientLoop))
    {
      Name = "TCP Client Thread",
      IsBackground = true
    }.Start();

    public static bool SetRemoteIP(string remoteAddress) => Netplay.SetRemoteIPOld(remoteAddress);

    public static bool SetRemoteIPOld(string remoteAddress)
    {
      try
      {
        IPAddress address;
        if (IPAddress.TryParse(remoteAddress, out address))
        {
          Netplay.ServerIP = address;
          Netplay.ServerIPText = address.ToString();
          return true;
        }
        IPAddress[] addressList = Dns.GetHostEntry(remoteAddress).AddressList;
        for (int index = 0; index < addressList.Length; ++index)
        {
          if (addressList[index].AddressFamily == AddressFamily.InterNetwork)
          {
            Netplay.ServerIP = addressList[index];
            Netplay.ServerIPText = remoteAddress;
            return true;
          }
        }
      }
      catch (Exception ex)
      {
      }
      return false;
    }

    public static void SetRemoteIPAsync(string remoteAddress, Action successCallBack)
    {
      try
      {
        IPAddress address;
        if (IPAddress.TryParse(remoteAddress, out address))
        {
          Netplay.ServerIP = address;
          Netplay.ServerIPText = address.ToString();
          successCallBack();
        }
        else
        {
          Netplay.InvalidateAllOngoingIPSetAttempts();
          Dns.BeginGetHostAddresses(remoteAddress, new AsyncCallback(Netplay.SetRemoteIPAsyncCallback), (object) new Netplay.SetRemoteIPRequestInfo()
          {
            RequestId = Netplay._currentRequestId,
            SuccessCallback = successCallBack,
            RemoteAddress = remoteAddress
          });
        }
      }
      catch (Exception ex)
      {
      }
    }

    public static void InvalidateAllOngoingIPSetAttempts() => ++Netplay._currentRequestId;

    private static void SetRemoteIPAsyncCallback(IAsyncResult ar)
    {
      Netplay.SetRemoteIPRequestInfo asyncState = (Netplay.SetRemoteIPRequestInfo) ar.AsyncState;
      if (asyncState.RequestId != Netplay._currentRequestId)
        return;
      try
      {
        bool flag = false;
        IPAddress[] hostAddresses = Dns.EndGetHostAddresses(ar);
        for (int index = 0; index < hostAddresses.Length; ++index)
        {
          if (hostAddresses[index].AddressFamily == AddressFamily.InterNetwork)
          {
            Netplay.ServerIP = hostAddresses[index];
            Netplay.ServerIPText = asyncState.RemoteAddress;
            flag = true;
            break;
          }
        }
        if (!flag)
          return;
        asyncState.SuccessCallback();
      }
      catch (Exception ex)
      {
      }
    }

    public static void Initialize()
    {
      NetMessage.buffer[256] = new MessageBuffer();
      NetMessage.buffer[256].whoAmI = 256;
    }

    public static void Update() => Netplay.UpdateClient();

    public static int GetSectionX(int x) => x / 200;

    public static int GetSectionY(int y) => y / 150;

    private static void BroadcastThread()
    {
      Netplay.BroadcastClient = new UdpClient();
      IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 0);
      Netplay.BroadcastClient.EnableBroadcast = true;
      DateTime dateTime = new DateTime(0L);
      byte[] array;
      using (MemoryStream memoryStream = new MemoryStream())
      {
        using (BinaryWriter binaryWriter = new BinaryWriter((Stream) memoryStream))
        {
          int num = 1010;
          binaryWriter.Write(num);
          binaryWriter.Write(Netplay.ListenPort);
          binaryWriter.Write(Main.worldName);
          binaryWriter.Write(Dns.GetHostName());
          binaryWriter.Write((ushort) Main.maxTilesX);
          binaryWriter.Write(Main.ActiveWorldFileData.HasCrimson);
          binaryWriter.Write(Main.ActiveWorldFileData.GameMode);
          binaryWriter.Write((byte) Main.maxNetPlayers);
          binaryWriter.Write((byte) 0);
          binaryWriter.Flush();
          array = memoryStream.ToArray();
        }
      }
      while (true)
      {
        int num = 0;
        for (int index = 0; index < (int) byte.MaxValue; ++index)
        {
          if (Main.player[index].active)
            ++num;
        }
        if (num > 0)
        {
          array[array.Length - 1] = (byte) num;
          try
          {
            Netplay.BroadcastClient.Send(array, array.Length, new IPEndPoint(IPAddress.Broadcast, 8888));
          }
          catch
          {
          }
        }
        Thread.Sleep(1000);
      }
    }

    public static void StartBroadCasting()
    {
      if (Netplay.broadcastThread != null)
        Netplay.StopBroadCasting();
      Netplay.broadcastThread = new Thread(new ThreadStart(Netplay.BroadcastThread));
      Netplay.broadcastThread.Start();
    }

    public static void StopBroadCasting()
    {
      if (Netplay.broadcastThread != null)
      {
        Netplay.broadcastThread.Abort();
        Netplay.broadcastThread = (Thread) null;
      }
      if (Netplay.BroadcastClient == null)
        return;
      Netplay.BroadcastClient.Close();
      Netplay.BroadcastClient = (UdpClient) null;
    }

    private class SetRemoteIPRequestInfo
    {
      public int RequestId;
      public Action SuccessCallback;
      public string RemoteAddress;
    }
  }
}