using AwInitilizer.Assist;
using CsuWebApiLib;
using InitializerModel;
using Newtonsoft.Json;
using PhihongEv.Lib;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace AwInitilizer.Procedure.WifRssiCheck
{
    public enum ErrorType
    {
        None,
        WifiModeDataNotFound,
        WifiModeNotClient,
        WifiRssiDataNotFound,
        WifiRssiLow,
    }

    public enum LogEvent
    {
        WifiRssi
    }

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

        private ProcedureLog.LogWriter<WifRssiCheckProcedure, LogEvent> LogWriter;

        private readonly static Dictionary<LogEvent, string> ReportDict = new Dictionary<LogEvent, string>()
        {
            { LogEvent.WifiRssi, "WifiRssi" }
        };

        private readonly static Dictionary<LogEvent, string> LogDict = new Dictionary<LogEvent, string>()
        {
            { LogEvent.WifiRssi, "Get Wifi Rssi : {0}" }
        };

        public WifRssiCheckProcedure() : base()
        {
            Name = "WiFi Rssi Check";
            Content = "Check Wifi Rssi Signal";

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

        internal override async Task<bool> Run()
        {
            //if (!UpdateData.SystemID.ModelName.Network.Description.Contains("WiFi"))
            if (UpdateData.SystemID.ModelName.GetWiFiCnt() == 0)
            {
                LogWriter.Log("Wifi not supported, skip procedure");

                return true;
            }

            //var updateWifiConfigResult = await SetWifiConfig();
            //if (!updateWifiConfigResult)
            //{
            //    LogWriter.Log("set wifi to station failed");
            //    return false;
            //}

            var checkResult = await CheckWifiRssi();
            return checkResult;
        }

        internal async Task<bool> SetWifiConfig()
        {
            var ssid = AppSettingConfig.Instance.WifiApSSID;
            var pwd = AppSettingConfig.Instance.WifiApPassword;
            EvApiResult<bool> cmdResult;

            int retryCnt = 0;
            do
            {
                LogWriter.Log("Trying to set wifi to station mode");
                cmdResult = await EvApi.SetWifiStationMode(ssid, pwd);
                if (cmdResult != null && cmdResult.Result)
                {
                    break;
                }
                await Task.Delay(TimeSpan.FromMinutes(2));
                retryCnt++;
            }
            while (retryCnt < 5);
            if (retryCnt >= 5)
            {
                return false;
            }

            var restartResult = await EvApi.Restart();
            if (restartResult == null || !restartResult.Result)
            {
                return false;
            }

            int pollingCnt;
            for (pollingCnt = 0; pollingCnt < 16; pollingCnt++)
            {
                await Task.Delay(TimeSpan.FromSeconds(15));
                var response = await ChekCsuBootCompelete();
                if (response)
                    break;
            }
            if (pollingCnt == 16)
            {
                LogWriter.Log("Wait reboot complete time out");
            }

            return cmdResult.Result;
        }

        internal async Task<bool> CheckWifiRssi()
        {
            var rssi = await GetWifiRssi();
            //LogWriter.Report(LogEvent.WifiRssi, rssi.ToString());
            if (rssi == 0)
            {
                LogWriter.Report(LogEvent.WifiRssi, rssi.ToString(), isError: true);
                return false;
            }
            else
            {
                var rssiCheckPass = rssi >= -80;
                if (rssiCheckPass)
                {
                    LogWriter.Report(LogEvent.WifiRssi, rssi.ToString());
                    return true;
                }
                else
                {
                    Error = ErrorType.WifiRssiLow;
                    LogWriter.Report(LogEvent.WifiRssi, rssi.ToString(), isError: true);
                    return false;
                }
            }
        }

        internal async Task<int> GetWifiRssi()
        {
            try
            {
                var result = await EvApi.GetWifiRssi();
                switch (result.Result.ErrorCode)
                {
                    case 0:
                    case 2:
                        Error = ErrorType.WifiModeDataNotFound;
                        break;
                    case 1:
                        Error = ErrorType.WifiModeNotClient;
                        break;
                    case 3:
                    case 4:
                    case 5:
                        Error = ErrorType.WifiRssiDataNotFound;
                        break;
                    default:
                        break;
                }
                LogWriter.Log($"GetResponse:{result.Response}", isDebugLog: true);
                return result.Result.Rssi;
            }
            catch (Exception e)
            {
                Error = ErrorType.WifiRssiDataNotFound;

                LogWriter.Log("Get Wifi Rssi Failed");
                LogWriter.Log(e.Message, isDebugLog: true);

                return 0;
            }
        }
    }
}