using System;
using System.Collections.Generic;
using System.Linq;
using static CMS_CORE_Library.DataStructures;

namespace Step.Model.DTOModels
{
    public class DTOAlarmsModel
    {
        public List<GenericAlarmModel> NcAlarms { get; set; }
        public List<DTOPlcAlarmModel> PlcAlarms { get; set; }
        public List<ProcessAlarmModel> ProcessAlarms { get; set; }

        public DTOAlarmsModel()
        {
            NcAlarms = new List<GenericAlarmModel>();
            PlcAlarms = new List<DTOPlcAlarmModel>();
            ProcessAlarms = new List<ProcessAlarmModel>();
        }

        public void Clear()
        {
            NcAlarms.Clear();
            PlcAlarms.Clear();
            ProcessAlarms.Clear();
        }

        public override bool Equals(object obj)
        {
            var item = obj as DTOAlarmsModel;

            // Object is not a DTOAlarmsModel instance
            if (item == null)
                return false;

            // If the numbers of the list's elemets are different, lists are different
            if (item.NcAlarms.Count != NcAlarms.Count || item.PlcAlarms.Count != this.PlcAlarms.Count || item.ProcessAlarms.Count != this.ProcessAlarms.Count)
                return false;

            // Check list's elements
            bool listAreEquals = item.NcAlarms.All(NcAlarms.Contains);
            if (!listAreEquals)
                return false;

            // Check list's elements
            listAreEquals = item.PlcAlarms.All(PlcAlarms.Contains);
            if (!listAreEquals)
                return false;
            
            // Check list's elements
            listAreEquals = item.ProcessAlarms.All(ProcessAlarms.Contains);
            if (!listAreEquals)
                return false;

            return true;
        }

        public DTOAlarmsModel IntersectModels(DTOAlarmsModel newAlarms)
        {
            DTOAlarmsModel result = new DTOAlarmsModel();
            // Get common data from Obj1 and Obj2
            result.NcAlarms = NcAlarms.Where(x => newAlarms.NcAlarms.Contains(x as GenericAlarmModel)).ToList();
            // Concat common data + new data
            result.NcAlarms = result.NcAlarms.Concat(
                newAlarms.NcAlarms.Where(x => !NcAlarms.Contains(x as GenericAlarmModel)).ToList() // Find not contained data in the old list
                ).ToList();

            // Get common data
            result.PlcAlarms = PlcAlarms.Where(x => newAlarms.PlcAlarms.Contains(x as DTOPlcAlarmModel)).ToList();
            // Concat common data + new data
            result.PlcAlarms = result.PlcAlarms.Concat(
                newAlarms.PlcAlarms.Where(x => !PlcAlarms.Contains(x as DTOPlcAlarmModel)).ToList() // Find not contained data in the old list
                ).ToList();

            // Get common data
            result.ProcessAlarms = ProcessAlarms.Where(x => newAlarms.ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList();

            // Concat common data + new data in the list
            result.ProcessAlarms = result.ProcessAlarms.Concat(
                newAlarms.ProcessAlarms.Where(x => !ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList()  // Find not contained data in the old list
                ).ToList();

            return result;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    public class GenericAlarmModel
    {
        public uint Id;
        public string Message;
        public DateTime DateTime;
        public bool RestorationIsEnabled;

        public override bool Equals(object obj)
        {
            var item = obj as GenericAlarmModel;

            if (item == null)
                return false;

            if (item.Id == Id)
                return true;
            else
                return false;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    public class ProcessAlarmModel : GenericAlarmModel
    {
        public int Process;

        public override bool Equals(object obj)
        {
            var item = obj as ProcessAlarmModel;

            if (item == null)
                return false;

            if (!base.Equals(item))
                return false;

            if (item.Process == Process)
                return true;
            else
                return false;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    public class DTOPlcAlarmModel : PlcAlarmModel
    {
        public DateTime DateTime;
        public bool RestorationIsEnabled;
    
        public override bool Equals(object obj)
        {
            var item = obj as DTOPlcAlarmModel;

            if (item == null)
                return false;

            if (item.Id != Id)
                return false;

            if (!item.Process.SequenceEqual(Process) || item.IsWarning != IsWarning || item.RestorationIsActive != RestorationIsActive)
                return false;

            return true;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    public class DTOAlarmConfigModel
    {
        public int Id;
        public bool RestoreIsEnabled;
    }
}