using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace AwInitilizer.Procedure.BasicInfoUpdate
{
    public enum ErrorType
    {
        None,
        EvseConnectFail,
        ModelNameWriteFail,
        SerialNumberWriteFail,
        RtcUpdateFail,
        SettingSaveFail,
        RestartConnectFail,
        ModelNameGetFail,
        ModelNameMismach,
        SerialNumberGetFail,
        SerialNumberMismach,
        UtcTimeMismatch,
    }

    public enum LogEvent
    {
        EvseConnect,
        ModelNameWrite,
        SerialNumberWrite,
        RtcUpdate,
        SettingSave,
        RestartConnect,
        ModelNameRead,
        SerialNumberRead,
        RtcRead,
    }

    public class BasicInfoUpdateProcedure : ProcedureBase
    {
        public ErrorType Error { get; set; } = ErrorType.None;

        private ProcedureLog.LogWriter<BasicInfoUpdateProcedure, LogEvent> LogWriter;

        private readonly static Dictionary<LogEvent, string> ReportDict = new Dictionary<LogEvent, string>()
        {
            {LogEvent.EvseConnect,"BaseUpdateSocketConnect" },
            {LogEvent.ModelNameWrite,"ModelNameWrite" },
            {LogEvent.SerialNumberWrite,"SerialNumberWrite" },
            {LogEvent.RtcUpdate,"RtcUpdate" },
            {LogEvent.SettingSave,"SettingSave" },
            {LogEvent.RestartConnect,"BaseUpdateSocketReConnect" },
            {LogEvent.ModelNameRead,"ModelNameRead" },
            {LogEvent.SerialNumberRead,"SerialNumberRead" },
            {LogEvent.RtcRead,"RtcRead" },
        };

        private readonly static Dictionary<LogEvent, string> LogDict = new Dictionary<LogEvent, string>()
        {
            {LogEvent.EvseConnect,"EVSE connect {0}" },
            {LogEvent.ModelNameWrite,"Model Name write {0}" },
            {LogEvent.SerialNumberWrite,"Serial Number write {0}" },
            {LogEvent.RtcUpdate,"RTC update {0}" },
            {LogEvent.SettingSave,"Setting save {0}" },
            {LogEvent.RestartConnect,"Evse reconnect after write {0}" },
            {LogEvent.ModelNameRead,"Model Name read {0}" },
            {LogEvent.SerialNumberRead,"Serial Number read {0}" },
            {LogEvent.RtcRead,"RTC time read {0}" },
        };

        public BasicInfoUpdateProcedure() : base()
        {
            Name = "Basic Intlize";
            Content = "Set and check Model Name,SerilNumber,DateTime.";

            LogWriter = new ProcedureLog.LogWriter<BasicInfoUpdateProcedure, LogEvent>(this)
            {
                ReportPair = ReportDict,
                LogPair = LogDict
            };
        }

        internal override async Task<bool> Run()
        {
            if (!await base.CheckAndCreateSocket())
            {
                LogWriter.Report(LogEvent.EvseConnect, "fail");
                Error = ErrorType.EvseConnectFail;

                //LogPair.Add("BaseUpdateSocketConnect", "fail");
                //InfoLog += "EVSE connect failed\n";
                //ReportLog.Add("EVSE connect failed");
                return false;
            }

            //base.serialPortocol.OnMsgReceived += SerialPortocol_OnMsgReceived; 
            if (!await serialPortocol.SetModelName(UpdateData.ModelName))
            {
                LogWriter.Report(LogEvent.ModelNameWrite, "fail");
                Error = ErrorType.ModelNameWriteFail;

                //LogPair.Add("ModelNameWrite", "fail");
                //InfoLog += "Model Name update failed\n";
                //Logger.Print("Model Name update Failed", isError: true);
                //ReportLog.Add("Model Name update Failed");
                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.ModelNameWrite, "success");

                //LogPair.Add("ModelNameWrite", "success");
                //Logger.Print("Model Name write Success");
            }

            if (!await serialPortocol.SetSerialNumber(UpdateData.SerialNumber))
            {
                LogWriter.Report(LogEvent.SerialNumberWrite, "fail");
                Error = ErrorType.SerialNumberWriteFail;

                //LogPair.Add("SerialNumberWrite", "fail");
                //InfoLog += "Serial Number update failed\n";
                //Logger.Print("Serial Number update Failed", isError: true);
                //ReportLog.Add("Serial Number update Failed");
                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.SerialNumberWrite, "success");

                //LogPair.Add("SerialNumberWrite", "success");
                //Logger.Print("Serial Number write Success");
            }

            var setDateTime = DateTime.Now.ToUniversalTime();

            if (!await serialPortocol.SetUTCTime(setDateTime))
            {
                LogWriter.Report(LogEvent.RtcUpdate, "fail");
                Error = ErrorType.RtcUpdateFail;

                //LogPair.Add("RtcUpdate", "fail");
                //InfoLog += "RTC update failed\n";
                //Logger.Print("RTC update Failed", isError: true);
                //ReportLog.Add("RTC update Failed");
                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.RtcUpdate, "success");

                //LogPair.Add("RtcUpdate", "success");
                //Logger.Print("RTC update write Success");
            }

            if (!await serialPortocol.SettingChangeConfirm())
            {
                LogWriter.Report(LogEvent.SettingSave, "fail");
                Error = ErrorType.SettingSaveFail;

                //LogPair.Add("SettingSave", "fail");
                //InfoLog += "Setting save request failed\n";
                //Logger.Print("Setting save Failed", isError: true);
                //ReportLog.Add("Setting save request Failed");
                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.SettingSave, "success");

                //LogPair.Add("SettingSave", "success");
                //Logger.Print("Setting save Success");
            }

            LogWriter.Log("Waiting EVSE reboot...");
            //Logger.Print("Waiting EVSE reboot...");
            serialPortocol.Close();
            await Task.Delay(TimeSpan.FromMinutes(1));

            if (!await base.CheckAndCreateSocket())
            {
                LogWriter.Report(LogEvent.RestartConnect, "fail");
                Error = ErrorType.RestartConnectFail;

                //LogPair.Add("BaseUpdateSocketReConnect", "fail");
                //InfoLog += "EVSE not found after reboot\n";
                //Logger.Print("EVSE reboot timeout", isError: true);
                //ReportLog.Add("EVSE not found after reboot");
                return false;
            }

            var receivedModelName = await serialPortocol.GetModelName();
            LogWriter.Report(LogEvent.ModelNameRead, receivedModelName);
            //LogPair.Add("ModelNameRead", receivedModelName);
            if (string.IsNullOrEmpty(receivedModelName))
            {
                LogWriter.Log("Model name get failed after reboot");
                LogWriter.Log(serialPortocol.LatestErrorMessage, isDebugLog: true);
                Error = ErrorType.ModelNameGetFail;

                //InfoLog += "Model name get failed after reboot\n";
                //Logger.Print("Model Name read Failed", isError: true);
                //ReportLog.Add("Model name get failed after reboot");
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read Model name : {0} , Expect:{1}", receivedModelName, UpdateData.ModelName));
                //ReportLog.Add(string.Format("Read Model name : {0} , Expect:{1}", receivedModelName, UpdateData.ModelName));
                //InfoLog += $"Get Updated Model Name { receivedModelName }\n";
                if (receivedModelName != UpdateData.ModelName)
                {
                    Error = ErrorType.ModelNameMismach;
                    //InfoLog += "Updated Model Name Mismatched\n";
                    //Logger.Print("Stored Model Name Mismatched", isError: true);
                    return false;
                }
                //Logger.Print("Model Name update Success");
            }

            var receivedSerialNumber = await serialPortocol.GetSerialNumber();
            LogWriter.Report(LogEvent.SerialNumberRead, receivedSerialNumber);
            //LogPair.Add("SerialNumberRead", receivedSerialNumber);
            if (string.IsNullOrEmpty(receivedSerialNumber))
            {
                LogWriter.Log("Serial number get failed after reboot");
                LogWriter.Log(serialPortocol.LatestErrorMessage, isDebugLog: true);

                Error = ErrorType.SerialNumberGetFail;

                //InfoLog += "Serial number get failed after reboot\n";
                //InfoLog += serialPortocol.LatestNullMessage +"\n";
                //Logger.Print("Stored Serial read Failed", isError: true);
                //Logger.Print(serialPortocol.LatestNullMessage);
                //ReportLog.Add("Serial number get failed after reboot");
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read Serial number : {0} , Expect:{1}", receivedSerialNumber, UpdateData.SerialNumber));
                //ReportLog.Add(string.Format("Read Serial number : {0} , Expect:{1}", receivedSerialNumber, UpdateData.SerialNumber));
                //InfoLog += $"Get Updated serial number { receivedSerialNumber }\n";
                if (receivedSerialNumber != UpdateData.SerialNumber)
                {
                    Error = ErrorType.SerialNumberMismach;

                    //InfoLog += "Updated serial number mismatched\n";
                    //Logger.Print("Stored Serial Number Mismatched", isError: true);
                    return false;
                }
                //Logger.Print("Serial Number update Success");
            }

            var receivedDateTime = await serialPortocol.GetUTCTime();
            //LogPair.Add("RtcRead", receivedDateTime?.ToString("yyyyMMddHHmmss"));
            LogWriter.Report(LogEvent.RtcRead, receivedDateTime?.ToString("yyyyMMddHHmmss"));
            if (receivedDateTime == null)
            {
                LogWriter.Log("UTC Time receive failed");

                //InfoLog += "UTC Time receive failed after reboot\n";
                //Logger.Print("UTC Time receive failed", isError: true);
                //ReportLog.Add("UTC Time receive failed after reboot");
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read UTC time : {0} , CurrentTime:{1}", receivedDateTime?.ToString("yyyyMMddHHmmss"), DateTime.Now.ToUniversalTime().ToString("yyyyMMddHHmmss")));
                //ReportLog.Add(string.Format("Read UTC time : {0} , CurrentTime:{1}", receivedDateTime?.ToString("yyyyMMddHHmmss"), DateTime.Now.ToUniversalTime().ToString("yyyyMMddHHmmss")));
                //InfoLog += $"UTC Time received : {receivedDateTime.Value.ToString("yyyyMMddHHmmss")}\n";
                var diff = receivedDateTime.Value - DateTime.Now.ToUniversalTime();
                if (Math.Abs(diff.TotalSeconds) > 10)
                {
                    Error = ErrorType.UtcTimeMismatch;

                    //InfoLog += "Stored UTC time Mismatched\n";
                    //Logger.Print("Stored UTC time Mismatched", isError: true);
                    return false;
                }
                else
                {
                    //Logger.Print("Model Name update Success");
                }
            }

            return true;
        }
    }
}