using Filter.Database.Account;
using Filter.Database.Character;
using Filter.Database.GameFilter;
using Filter.Handlers.IRC;
using Filter.Handlers.Login;
using Filter.Handlers.Manager;
using Filter.Networking.Instances;
using Filter.Networking.IRC;
using Filter.Networking.Login;
using Filter.Networking.Manager;
using Filter.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Threading;
using System.Timers;

namespace Filter
{
	internal class Program
	{
		private static AccountDB RealAccountData;

		private static CharacterDB RealCharacterData;

		private static GameFilterDB RealGameFilterData;

		public static SqlConnectionStringBuilder CharacterString;

		private static System.Timers.Timer RefreshTimer;

		public static Dictionary<string, string> ConfigValues;

		public static Dictionary<int, string> ItemNames;

		public static Dictionary<int, string> ClassNames;

		public static List<RespawnTimer> BossRespawns;

		public static Dictionary<string, int> LoginToManagerTransfer;

		public static Dictionary<int, IRCClient> IRCConnections;

		public static IRCHandlerLoader IRCHandlers;

		public static LoginHandlerLoader LoginHandlers;

		public static ManagerHandlerLoader ManagerHandlers;

		public static List<ManagerClient> ManagerLoggedIn;

		public static Lottery TheLottery;

		public static IRCListener IRCListen;

		public static IRCServer IRCConnect;

		private static LoginListener LoginListen;

		private static ManagerListener ManagerListen;

		public static AccountDB AccountData
		{
			get
			{
				AccountDB realAccountData;
				if (Program.RealAccountData.Database.Connection.State == ConnectionState.Open)
				{
					return Program.RealAccountData;
				}
				try
				{
					Program.RealAccountData.Database.Connection.Open();
					Thread.Sleep(250);
					realAccountData = Program.RealAccountData;
				}
				catch
				{
					realAccountData = new AccountDB();
				}
				return realAccountData;
			}
			set
			{
				Program.RealAccountData = value;
			}
		}

		public static CharacterDB CharacterData
		{
			get
			{
				CharacterDB realCharacterData;
				if (Program.RealCharacterData.Database.Connection.State == ConnectionState.Open)
				{
					return Program.RealCharacterData;
				}
				try
				{
					Program.RealCharacterData.Database.Connection.Open();
					Thread.Sleep(250);
					realCharacterData = Program.RealCharacterData;
				}
				catch
				{
					realCharacterData = new CharacterDB();
				}
				return realCharacterData;
			}
			set
			{
				Program.RealCharacterData = value;
			}
		}

		public static GameFilterDB GameFilterData
		{
			get
			{
				GameFilterDB realGameFilterData;
				if (Program.RealGameFilterData.Database.Connection.State == ConnectionState.Open)
				{
					return Program.RealGameFilterData;
				}
				try
				{
					Program.RealGameFilterData.Database.Connection.Open();
					Thread.Sleep(250);
					realGameFilterData = Program.RealGameFilterData;
				}
				catch
				{
					realGameFilterData = new GameFilterDB();
				}
				return realGameFilterData;
			}
			set
			{
				Program.RealGameFilterData = value;
			}
		}

		public Program()
		{
		}

		private static void CurrentDomain_UnhandledException(object Sender, UnhandledExceptionEventArgs Args)
		{
			Program.WriteError((Exception)Args.ExceptionObject);
			Console.ReadLine();
		}

		public static TimeSpan GetSpan(DateTime CheckTime)
		{
			return TimeSpan.FromSeconds((CheckTime - DateTime.Now).TotalSeconds);
		}

		private static void Main()
		{
			Console.Title = "Fiesta filter";
			try
			{
				Program.AccountData = new AccountDB();
				Program.AccountData.tAccounts.Count<tAccount>();
			}
			catch (SqlException sqlException)
			{
				Environment.Exit(0);
			}
			try
			{
				Program.GameFilterData = new GameFilterDB();
				Program.GameFilterData.Admins.Count<Admin>();
			}
			catch (SqlException sqlException1)
			{
				Environment.Exit(0);
			}
			try
			{
				Program.CharacterData = new CharacterDB();
				Program.CharacterData.tCharacters.Count<tCharacter>();
				Program.CharacterString = new SqlConnectionStringBuilder()
				{
					ConnectionString = Program.CharacterData.Database.Connection.ConnectionString
				};
			}
			catch (SqlException sqlException2)
			{
				Environment.Exit(0);
			}
			Program.RefreshTimer = new System.Timers.Timer()
			{
				AutoReset = true
			};
			Program.RefreshTimer.Elapsed += new ElapsedEventHandler(Program.RefreshTimer_Elapsed);
			Program.RefreshTimer.Interval = 7200000;
			Program.RefreshTimer.Start();
			AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Program.CurrentDomain_UnhandledException);
			SHNFile sHNFile = null;
			if (!File.Exists(string.Format("{0}/EchoConfig.shn", AppDomain.CurrentDomain.BaseDirectory)))
			{
				Environment.Exit(0);
			}
			else
			{
				sHNFile = new SHNFile(string.Format("{0}/EchoConfig.shn", AppDomain.CurrentDomain.BaseDirectory));
			}
			Program.ConfigValues = new Dictionary<string, string>();
			foreach (DataRow row in sHNFile.table.Rows)
			{
				Program.ConfigValues.Add(Convert.ToString(row[0]), Convert.ToString(row[1]));
			}
			SHNFile sHNFile1 = null;
			if (!File.Exists(string.Format("{0}/ItemInfo.shn", AppDomain.CurrentDomain.BaseDirectory)))
			{
				Environment.Exit(0);
			}
			else
			{
				sHNFile1 = new SHNFile(string.Format("{0}/ItemInfo.shn", AppDomain.CurrentDomain.BaseDirectory));
			}
			Program.ItemNames = new Dictionary<int, string>();
			foreach (DataRow dataRow in sHNFile1.table.Rows)
			{
				Program.ItemNames.Add(Convert.ToInt32(dataRow[0]), Convert.ToString(dataRow[2]));
			}
			SHNFile sHNFile2 = null;
			if (!File.Exists(string.Format("{0}/ClassName.shn", AppDomain.CurrentDomain.BaseDirectory)))
			{
				Environment.Exit(0);
			}
			else
			{
				sHNFile2 = new SHNFile(string.Format("{0}/ClassName.shn", AppDomain.CurrentDomain.BaseDirectory));
			}
			Program.ClassNames = new Dictionary<int, string>();
			foreach (DataRow row1 in sHNFile2.table.Rows)
			{
				Program.ClassNames.Add(Convert.ToInt32(row1[0]), Convert.ToString(row1[3]));
			}
			Program.BossRespawns = new List<RespawnTimer>();
			foreach (BossDeath bossDeath in (IEnumerable<BossDeath>)Program.GameFilterData.BossDeaths)
			{
				RespawnTimer respawnTimer = new RespawnTimer()
				{
					AnnouncementID = bossDeath.AnnouncementID,
					CheckName = bossDeath.CheckName,
					BossName = bossDeath.BossName,
					RespawnSeconds = bossDeath.RespawnSeconds,
					RespawnDate = DateTime.Now
				};
				respawnTimer.Create();
				Program.BossRespawns.Add(respawnTimer);
			}
			Program.LoginToManagerTransfer = new Dictionary<string, int>();
			Program.LoginHandlers = new LoginHandlerLoader();
			Program.ManagerHandlers = new ManagerHandlerLoader();
			Program.IRCHandlers = new IRCHandlerLoader();
			Program.ManagerLoggedIn = new List<ManagerClient>();
			Program.IRCConnections = new Dictionary<int, IRCClient>();
			Program.TheLottery = new Lottery();
			Program.TheLottery.Create();
			Program.TheLottery.StartLottery();
			if (Convert.ToBoolean(Program.ConfigValues["IRC_Enabled"]))
			{
				if (!Convert.ToBoolean(Program.ConfigValues["IRC_MainServer"]))
				{
					Program.IRCConnect = new IRCServer(Program.ConfigValues["IRC_ConnectIP"]);
				}
				else
				{
					Program.IRCListen = new IRCListener();
				}
			}
			Program.LoginListen = new LoginListener();
			Program.ManagerListen = new ManagerListener();
			Console.ReadLine();
		}

		private static void RefreshTimer_Elapsed(object Sender, ElapsedEventArgs Args)
		{
			Echo.SendWhisper(true, "Attempting to restart listeners... You may see a bit of lag, do not worry.", new object[0]);
			Program.LoginListen.Recreate(100);
			Program.LoginListen.Accept();
			Program.ManagerListen.Recreate(50000);
			Program.ManagerListen.Accept();
			Echo.SendWhisper(true, "Lag should be settled now.", new object[0]);
		}

		public static void WriteError(Exception Error)
		{
			try
			{
				string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
				DateTime now = DateTime.Now;
				StreamWriter streamWriter = new StreamWriter(string.Format("{0}/{1}.Broke", baseDirectory, now.ToString("[dd.MM]HH.mm.ss")));
				streamWriter.WriteLine(Error.ToString());
				streamWriter.Flush();
				streamWriter.Close();
				streamWriter.Dispose();
			}
			catch
			{
			}
		}
	}
}