using MDS.Controls;
using MDS.DataModels;
using MDS.Units;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;

namespace MDS
{
    /// <summary>
    /// Логика взаимодействия для App.xaml
    /// </summary>
    public partial class App : Application, INotifyPropertyChanged
    {
        public enum Mode { Demo, Study, Training, Exam, Quiz};

        private static string _client;
        private static string _workplace;

        private static bool _checker;
        public static bool Checker
        {
            set
            {
                if (value != _checker)
                {
                    _checker = value;
                }
            }
            get { return _checker; }
        }

        private static ObservableCollection<Client> _clients = new ObservableCollection<Client>();
        public static ObservableCollection<Client> Clients
        {
            get { return _clients; }
        }

        public static Frame MainFrame;

        private static TelnetDotNet Telnet;

        public static Assembly CurrentDevice;

        private static ObservableCollection<Unit> _units;
        public static ObservableCollection<Unit> Units
        {
            get { return _units; }
            private set
            {
                if (value != _units)
                {
                    _units = value;
                }
            }
        }

        private static Mode _currentMode;
        public static Mode CurrentMode
        {
            get { return _currentMode; }
            set
            {
                if (value != _currentMode)
                {
                    _currentMode = value;
                }
            }
        }

        private static Random rand = new Random();
        public static Random Rand
        {
            get { return rand; }
        }

        private static Tutorial activeTutorial;
        public static Tutorial ActiveTutorial
        {
            get { return activeTutorial; }
            set
            {
                if (value != activeTutorial)
                {
                    activeTutorial = value;
                    if(activeTutorial.RandValues!=null)
                    {
                        foreach(var val in activeTutorial.RandValues)
                        {
                            val.Min = RandVarReplace(val.Min, activeTutorial.RandValues);
                            val.Max = RandVarReplace(val.Max, activeTutorial.RandValues);

                            val.Value = Rand.Next(int.Parse(val.Min), int.Parse(val.Max));
                            if (val.Mod != 0)
                                val.Value = val.Value - val.Value % val.Mod;
                        }
                    }
                    activeTutorial.ExamDescription = RandVarReplace(activeTutorial.ExamDescription, activeTutorial.RandValues);
                    foreach (var step in activeTutorial.Steps)
                    {
                        step.Title = RandVarReplace(step.Title, activeTutorial.RandValues);
                        step.Command = RandVarReplace(step.Command, activeTutorial.RandValues);
                        if(step.Conditions!=null)
                        {
                            foreach(var cond in step.Conditions)
                                cond.Value = RandVarReplace(cond.Value, activeTutorial.RandValues);
                        }
                    }

                }
            }
        }



        public static string RandVarReplace(string text, List<RandValue> values)
        {
            string output = text;
            if (values != null)
            {
                for (int i = 0; i < values.Count(); i++)
                    output = output.Replace("[" + i + "]", values[i].Value.ToString());
            }
            return output;
        }

        public static Window TutorialWindow;

        public App()
        {
            Units = new ObservableCollection<Unit>();
            Telnet = new TelnetDotNet();
            Telnet.MessageRecieved += Telnet_MessageRecieved;
            Current.Exit += Current_Exit;
        }

        void Current_Exit(object sender, ExitEventArgs e)
        {
            Telnet.Close();
        }

        public static void StartDemo(string workplace)
        {
            Task.Run(() =>
            {
                Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    MainFrame.Content = Activator.CreateInstance(CurrentDevice.GetType(workplace), Mode.Demo.ToString());
                }));
            });
        }

        public static void Start(string workplace)
        {
            Task.Run(() =>
            {
                Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    try
                    {
                        MainFrame.Content = Activator.CreateInstance(CurrentDevice.GetType(workplace), CurrentMode.ToString());
                    }
                    catch(Exception)
                    {
                        MainFrame.Content = Activator.CreateInstance(CurrentDevice.GetType(workplace));
                    }
                    switch (CurrentMode)
                    {
                        case Mode.Study:
                            TutorialWindow = new TutorialWindow();
                            TutorialWindow.Topmost = true;
                            TutorialWindow.Show();
                            break;
                        case Mode.Exam:
                            TutorialWindow = new ExamWindow();
                            TutorialWindow.Topmost = true;
                            TutorialWindow.Show();
                            break;
                    }
                }));
            });
        }

        public static void PrepareControls()
        {
            if (ActiveTutorial != null && ActiveTutorial.PrepareControls != null)
            {
                foreach (var control in ActiveTutorial.PrepareControls)
                {
                    CheckBox chkBox = FindChild(Current.MainWindow, control) as CheckBox;
                    if (chkBox != null)
                    {
                        chkBox.IsChecked = !chkBox.IsChecked;
                    }
                    else
                    { 
                        try
                        { //TODO: програмное нажатие кнопки
                            (App.MainFrame.Content as BaseFrame).prepareElement(control);
                        }
                        catch (Exception) { }
                    }
                }
            }
        }

        public static void Stop()
        {
            if (TutorialWindow != null)
                TutorialWindow.Close();
            Telnet.Close();
            Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                if (App.Current.MainWindow.WindowStyle == WindowStyle.None)
                {
                    App.Current.MainWindow.WindowStyle = WindowStyle.SingleBorderWindow;
                    App.Current.MainWindow.ResizeMode = ResizeMode.CanResize;
                    App.Current.MainWindow.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                    App.Current.MainWindow.WindowState = WindowState.Normal;

                    App.Current.MainWindow.Hide();
                    App.Current.MainWindow.Show();
                }
                MainFrame.Source = new Uri("MenuPage.xaml", UriKind.RelativeOrAbsolute);
            }));
            foreach (var u in Units)
                u.Dispose();
            Units.Clear();
        }

        public static bool BroadcastMessage(string Message, bool FromTelnet)
        {
            if (Message != null)
            {
                bool MessageAccepted = false;
                foreach (Unit unit in Units)
                {
                    if (unit.RecieveMessage(Message))
                    {
                        MessageAccepted = true;
                    }
                }
                if (Telnet.IsConnected && !FromTelnet)
                {
                    Telnet.Send(Message);
                }

                if (CurrentMode == Mode.Exam || CurrentMode == Mode.Study)
                {
                    if (ActiveTutorial.CurrentStep != null && ActiveTutorial.CurrentStep.Command != null)
                    {
                        if (Message.Contains(ActiveTutorial.CurrentStep.Command))
                        {
                            if (ActiveTutorial.CurrentStep.Conditions != null && ActiveTutorial.CurrentStep.Conditions.Count > 0)
                            {
                                foreach (var cond in ActiveTutorial.CurrentStep.Conditions)
                                {
                                    object unit = App.Units.FirstOrDefault(u => u.Name == cond.UnitName);
                                    if (unit != null)
                                    {
                                        string[] path = cond.Path.Split('/');
                                        PropertyInfo propertyInfo = null;
                                        object property = unit;

                                        Type type = unit.GetType();
                                        foreach (var segment in path)
                                        {
                                            if (segment[0] == '[')
                                            {
                                                if (!segment.Contains('='))
                                                {
                                                    int index;
                                                    int.TryParse(segment.Substring(1, segment.Length - 2), out index);
                                                    int i = 0;
                                                    foreach (var element in property as IEnumerable)
                                                    {
                                                        if (index == i)
                                                        {
                                                            property = element;
                                                            break;
                                                        }
                                                        i++;
                                                    }
                                                }
                                                else
                                                {
                                                    int eqSignPos = segment.IndexOf('=');
                                                    string key = segment.Substring(1, eqSignPos - 1);
                                                    string value = segment.Substring(eqSignPos + 1, segment.Length - eqSignPos - 2);
                                                    foreach (var element in property as IEnumerable)
                                                    {
                                                        PropertyInfo elemInfo = element.GetType().GetProperty(key);
                                                        if (elemInfo.GetValue(element).ToString() == value)
                                                        {
                                                            property = element;
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                propertyInfo = type.GetProperty(segment);
                                                if (propertyInfo != null)
                                                    property = propertyInfo.GetValue(property);
                                            }
                                            if (property == null)
                                                break;
                                            type = property.GetType();
                                        }
                                        if (cond.Tolerance != 0)
                                        {
                                            if (Math.Abs(double.Parse(property.ToString()) - double.Parse(cond.Value)) <= cond.Tolerance)
                                                cond.IsMet = true;
                                        }
                                        else
                                        {
                                            if (property != null)
                                            {
                                                switch (type.Name)
                                                {
                                                    case "bool":
                                                        if (((bool)property == true && cond.Value == "True") ||
                                                          ((bool)property == false && cond.Value == "False"))
                                                            cond.IsMet = true;
                                                        break;
                                                    default:
                                                        if (property.ToString() == (cond.Value))
                                                            cond.IsMet = true;
                                                        break;
                                                }
                                            }
                                        }
                                    }
                                }
                                if (ActiveTutorial.CurrentStep.Conditions.Where(c => c.IsMet).Count() == ActiveTutorial.CurrentStep.Conditions.Count())
                                    TutorialStepCompleted();
                            }
                            else TutorialStepCompleted();
                        }
                    }
                }
                return MessageAccepted;
            }
            else
            {
                return false;
            }
        }

        private static void TutorialStepCompleted()
        {
            ActiveTutorial.NextStep();
        }

        public static void Connect(string Server, string Client, string Workplace)
        {
            _client = Client;
            _workplace = Workplace;
            Telnet.Connected += Telnet_Connected;
            Telnet.Connect(Server, 27027);
        }

        static void Telnet_Connected(object sender, EventArgs e)
        {
            Telnet.Send(String.Format("Connect {0} {1}", _client, _workplace));
            App.Current.Dispatcher.BeginInvoke(new Action(() => Start(_workplace)));
        }

        public static void StartServer(int Port)
        {
            Telnet.StartServer(Port);
        }

        static void Telnet_MessageRecieved(object sender, string e)
        {
            if (e != null)
            {
                String[] Comms = e.Split('\n');

                List<String> Commands = new List<string>(Comms);
                Commands.Sort();
                foreach (string command in Commands)
                {
                    if (command != String.Empty)
                    {
                        String[] Message = command.Split(' ');
                        switch (Message[0])
                        {
                            case "Connect":
                                //TODO
                                if (Checker == true && Telnet.ClientSocket == null)
                                {
                                    string[] MessageSplitted = {""};
                                    MessageSplitted = Message[2].Split(new string[] { "Big" }, StringSplitOptions.None);
                                    if (MessageSplitted.Length < 2) {
                                        MessageSplitted = Message[2].Split(new string[] { "Small" }, StringSplitOptions.None);
                                    }

                                    if (Message[2].Contains("OperatorPage"))
                                    {
                                        int op_counter = 0;

                                        if (MainFrame.Content.ToString().Contains("OperatorPage"))
                                            op_counter += 1;

                                        foreach (Client imposter in Clients)
                                            if (imposter.Workspace.Contains("OperatorPage"))
                                                op_counter += 1;

                                        if (op_counter < 2)
                                            Clients.Add(new Client(Message[1], Message[2]));
                                        else
                                            Telnet.Send(String.Format("You are impostor {0}", Message[1]));

                                    }
                                    else
                                    {
                                        if(!MainFrame.Content.ToString().Contains(MessageSplitted[1]))
                                        {
                                            foreach (Client imposter in Clients)
                                                if (imposter.Workspace == Message[2])
                                                {
                                                    Telnet.Send(String.Format("You are impostor {0}", Message[1]));
                                                    break;
                                                }
                                            Clients.Add(new Client(Message[1], Message[2]));
                                        }
                                        else
                                            Telnet.Send(String.Format("You are impostor {0}", Message[1]));
                                    }
                                    
                                }
                                else
                                    Clients.Add(new Client(Message[1], Message[2]));
                                break;

                            case "You":
                                if (Message[3] == Telnet.ClientSocket.LocalEndPoint.ToString().Split(':')[0])
                                {
                                    App.Stop();
                                    MessageBox.Show("Server closed connection", "Closed", MessageBoxButton.OK, MessageBoxImage.Information);
                                }
                                else
                                {
                                    foreach (Client impostor in Clients)
                                    {
                                        if (Message[3] == impostor.IPAddress)
                                        {
                                            Clients.Remove(impostor);
                                        }
                                    }
                                }
                                break;

                            default:
                                if(command != "CommonInfoArrayNotif 53 0")
                                    BroadcastMessage(command, true);
                                break;
                        }
                    }
                }
            }
        }

        public static DependencyObject FindChild(DependencyObject parent, string name)
        {
            if (parent == null || string.IsNullOrEmpty(name))
                return null;
            if (parent is FrameworkElement && (parent as FrameworkElement).Name == name)
                return parent;
            DependencyObject result = null;
            if (parent is FrameworkElement)
                (parent as FrameworkElement).ApplyTemplate();
            int childrenCount = VisualTreeHelper.GetChildrenCount(parent);
            for (int i = 0; i < childrenCount; i++)
            {
                var child = VisualTreeHelper.GetChild(parent, i);
                result = FindChild(child, name);
                if (result != null)
                    break;
            }
            return result;
        }

        public static double GetAngle(double x, double y)
        {
            if (x == 0)
            {
                if (y > 0)
                    return 180;
                else
                    return 0;
            }
            else
            {
                if (x > 0 && y < 0)
                    return 90 - Math.Atan(Math.Abs(y) / x) * 180 / Math.PI;
                if (x > 0 && y >= 0)
                    return Math.Atan(y / x) * 180 / Math.PI + 90;
                if (x < 0 && y >= 0)
                    return -Math.Atan(y / Math.Abs(x)) * 180 / Math.PI + 270;
                if (x < 0 && y < 0)
                    return Math.Atan(Math.Abs(y) / Math.Abs(x)) * 180 / Math.PI + 270;
            }
            return 0;
        }

                                    #region INotify
        public event PropertyChangedEventHandler PropertyChanged;

        public void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this,
                    new PropertyChangedEventArgs(propertyName));
            }
        }
                                    #endregion
    }
}