DC_Initlizer/AwInitilizer/Procedure/ButtonStatusCheckPorcedure.cs

using AwInitilizer.Assist;
using AwInitilizer.Model;
using CsuWebApiLib;
using CsuWebApiLib.Model;
using FluentFTP;
using InitializerModel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.AccessControl;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web;
using System.Windows;

namespace AwInitilizer.Procedure.ButtonStatusCheck
{
    public enum ErrorType
    {
        None,
        ConnectFail,
        GetStatusFail,
        FirstButtonCheckFail,
        SecondButtonCheckFail,
        EmergencyButtonCheckFail,
        ThirdButtonCheckFail
    }

    public enum LogEvent
    {
        UnpressButtonTest
    }

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

        private ProcedureLog.LogWriter<ButtonStatusCheckPorcedure, LogEvent> LogWriter;

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

        private readonly static Dictionary<LogEvent, string> LogDict = new Dictionary<LogEvent, string>()
        {
            { LogEvent.UnpressButtonTest, "Unpress check result" }
        };

        private HintDialog hintDialog = new HintDialog();
        private bool isBtn1NeedTest = false;
        private bool isBtn2NeedTest = false;
        private bool isBtn3NeedTest = false;
        private bool isEmergencyNeedTest = false;

        public ButtonStatusCheckPorcedure() : base()
        {
            Name = "Button Press Test";
            Content = "Interaction to test button status";

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

        internal override async Task<bool> Run()
        {
            if (UpdateData.ButtonTestMode == ButtonTestModeType.SkipButtonTest)
            {
                return true;
            }

            UpdateButtonNeedTestVar();

            var response = await GetButtonStatus();
            if (response == null)
            {
                return false;
            }

            //stage 1 - unpress all
            if (!await CheckUnpressAllBtn())
            {
                return false;
            }

            //stage 2 - check press sequence
            //Logger.Print("Button press Status check Start");
            //MessageBox.Show("Press Button1,Button2,EmergencyButton in order\neach press continuous 2 secondes\nPress Ok to start", "Starting Button test");

            //Button1,Button2,Button3,EmergencyButton in order 0,1,2,3
            for (int testType = 0; testType < 4; testType++)
            {
                if ((!isBtn1NeedTest && testType == 0) ||
                    (!isBtn2NeedTest && testType == 1) ||
                    (!isBtn3NeedTest && testType == 2) ||
                    (!isEmergencyNeedTest && testType == 3))
                {
                    continue;
                }

                var checkResult = await PressBtnCheck(testType);
                if (!checkResult)
                {
                    switch (testType)
                    {
                        case 0:
                            Error = ErrorType.FirstButtonCheckFail;
                            break;
                        case 1:
                            Error = ErrorType.SecondButtonCheckFail;
                            break;
                        case 2:
                            Error = ErrorType.ThirdButtonCheckFail;
                            break;
                        case 3:
                            Error = ErrorType.EmergencyButtonCheckFail;
                            break;
                    }
                    return false;
                }
            }
            return true;
        }

        private async Task<bool> CheckUnpressAllBtn()
        {
            ShowDialog(
                Resx.AppResources.BtnPressUnpressHint,
                Resx.AppResources.BtnPressHintTitle,
                Resx.AppResources.Confirm,
                "", cancelAble: true);

            ButtonStatus status = await GetButtonStatus();

            if (status == null)
            {
                return false;
            }

            //LogWriter.Report(LogEvent.UnpressButtonTest, string.Format("{0}{1}{2}", status.Button1, status.Button2, status.EmergencyButton));

            LogWriter.Log(string.Format("Button unpress test result : {0}/{1}/{2}/{3}, Expect:0000",
                status.Button1, status.Button2, status.Button3, status.EmergencyButton));

            LogWriter.Log(
                string.Format("Button1:{0},Button2:{1},Button3:{2},EmgerncyButton:{3}",
                    GetBtnStatusString(status.Button1),
                    GetBtnStatusString(status.Button2),
                    GetBtnStatusString(status.Button3),
                    GetBtnStatusString(status.EmergencyButton)
                ));

            bool isAllMatched = true;
            if (status != null)
            {
                if (isBtn1NeedTest && status.Button1 != 0)
                {
                    Error = ErrorType.FirstButtonCheckFail;
                    LogWriter.Log("Button1 status ERROR, unpress is expected", isError: true);
                    isAllMatched = false;
                }

                if (isBtn2NeedTest && status.Button2 != 0)
                {
                    Error = ErrorType.SecondButtonCheckFail;
                    LogWriter.Log("Button2 status ERROR, unpress is expected", isError: true);
                    isAllMatched = false;
                }

                if (isBtn3NeedTest && status.Button3 != 0)
                {
                    Error = ErrorType.ThirdButtonCheckFail;
                    LogWriter.Log("Button3 status ERROR, unpress is expected", isError: true);
                    isAllMatched = false;
                }

                if (isEmergencyNeedTest && status.EmergencyButton != 0)
                {
                    Error = ErrorType.EmergencyButtonCheckFail;
                    LogWriter.Log("EmergencyButton status ERROR, unpress is expected", isError: true);
                    isAllMatched = false;
                }

                if (isAllMatched)
                {
                    LogWriter.Log("Unpress Check passed");
                    LogWriter.Report(LogEvent.UnpressButtonTest, string.Format("{0}{1}{2}{3}", status.Button1, status.Button2, status.Button3, status.EmergencyButton));
                    return true;
                }
                else
                {
                    LogWriter.Report(LogEvent.UnpressButtonTest, string.Format("{0}{1}{2}{3}", status.Button1, status.Button2, status.Button3, status.EmergencyButton), isError: true);
                    return false;
                }
            }
            else
            {
                LogWriter.Log("Unpress Check: Get button press status Failed", isError: true);
                LogWriter.Report(LogEvent.UnpressButtonTest, "empty", isError: true);
                return false;
            }
        }

        private async Task<bool> PressBtnCheck(int btnInt)
        {

            string btn, btnLang, imgUrl;
            (btn, btnLang, imgUrl) = GetBtnParam(btnInt);

            if (btnInt == 3)
            {
                ShowEmergencyBtnPressRequestDialog(imgUrl);
            }
            else
            {
                ShowBtnPressRequestDialog(btnLang, imgUrl);
            }

            var btnStatus = await WaitAndtGetPressBtn();
            if (btnStatus == null)
            {
                return false;
            }

            //LogWriter.Report($"{btn}PressTest", string.Format("{0}{1}{2}", btnStatus.Button1, btnStatus.Button2, btnStatus.EmergencyButton));
            LogWriter.Log($"Press check stage {btn} result:");
            LogWriter.Log(
                string.Format("Button1:{0},Button2:{1},Button3:{2},EmgerncyButton:{3}",
                    GetBtnStatusString(btnStatus.Button1),
                    GetBtnStatusString(btnStatus.Button2),
                    GetBtnStatusString(btnStatus.Button3),
                    GetBtnStatusString(btnStatus.EmergencyButton)
                    ));

            DismisDialog();
            var btnStatusIsMatchedRequired = CheckOneBtnPressStatus(btnInt, btnStatus);
            LogWriter.Report($"{btn}PressTest", string.Format("{0}{1}{2}{3}", btnStatus.Button1, btnStatus.Button2, btnStatus.Button3, btnStatus.EmergencyButton), isError: !btnStatusIsMatchedRequired);
            return btnStatusIsMatchedRequired;
        }

        private async Task<ButtonStatus> WaitAndtGetPressBtn()
        {
            ButtonStatus pressStatus = null;
            //retry 60 times, 60*0.5 = 30 seconds 
            int testCnt;
            for (testCnt = 0; testCnt < 60; testCnt++)
            {
                await Task.Delay(500);
                pressStatus = await GetButtonStatus();
                if (pressStatus == null)
                {
                    return null;
                }

                if (IsAnyButtonPressed(pressStatus))
                {

                    await WaitAllBtnRelease();
                    break;
                }
            }
            return pressStatus;
        }

        private bool CheckOneBtnPressStatus(int btnInt, ButtonStatus buttonStatus)
        {
            if (isBtn1NeedTest &&
                (buttonStatus.Button1 is null || buttonStatus.Button1 == (btnInt == 0 ? 0 : 1))
                )
            {
                return false;
            }

            if (isBtn2NeedTest &&
                (buttonStatus.Button2 is null || buttonStatus.Button2 == (btnInt == 1 ? 0 : 1))
                )
            {
                return false;
            }

            if (isBtn3NeedTest &&
                (buttonStatus.Button3 is null || buttonStatus.Button3 == (btnInt == 2 ? 0 : 1))
                )
            {
                return false;
            }

            if (isEmergencyNeedTest &&
                (buttonStatus.EmergencyButton is null || buttonStatus.EmergencyButton == (btnInt == 3 ? 0 : 1))
                )
            {
                return false;
            }

            return true;
        }

        private void ShowEmergencyBtnPressRequestDialog(string imgUrl)
        {
            ShowDialog(
                string.Format(Resx.AppResources.EmergencyBtnPressPressHint),
                Resx.AppResources.BtnPressHintTitle,
                "", imgUrl, cancelAble: false);
        }

        private void ShowBtnPressRequestDialog(string btnLang, string imgUrl)
        {
            ShowDialog(
                string.Format(Resx.AppResources.BtnPressPressHint, btnLang),
                Resx.AppResources.BtnPressHintTitle,
                "", imgUrl, cancelAble: false);
        }

        private (string btn, string btnLang, string imgUrl) GetBtnParam(int btnInt)
        {
            string btn, btnLang, imgUrl;
            switch (btnInt)
            {
                case 0:
                    btn = "Blue Button";
                    btnLang = Resx.AppResources.BtnPressBlueBtn;
                    imgUrl = "pack://application:,,,/AwInitilizer;component/Image/Blue.png";
                    break;
                case 1:
                    btn = "Green Button";
                    btnLang = Resx.AppResources.BtnPressGreenBtn;
                    imgUrl = "pack://application:,,,/AwInitilizer;component/Image/Green.png";
                    break;
                case 2:
                    btn = "Third Button";
                    btnLang = Resx.AppResources.BtnPressThirdBtn;
                    imgUrl = "";
                    break;
                case 3:
                    btn = "EmergencyButton";
                    btnLang = Resx.AppResources.BtnPressEmergencyBtn;
                    imgUrl = "pack://application:,,,/AwInitilizer;component/Image/Emergency.png";
                    break;
                default:
                    btn = "";
                    btnLang = "";
                    imgUrl = null;
                    break;
            };
            return (btn, btnLang, imgUrl);
        }

        private async Task WaitAllBtnRelease()
        {
            ButtonStatus pressStatus;
            //wait release
            for (var releaseCnt = 0; releaseCnt < 20; releaseCnt++)
            {
                await Task.Delay(500);
                pressStatus = await GetButtonStatus();
                if (pressStatus == null)
                {
                    //InfoLog += "Get Butoon state failed\n";
                    //Logger.Print("Get Butoon state failed");
                    continue;
                }

                if (!IsAnyButtonPressed(pressStatus))
                {
                    break;
                }
            }
        }

        internal async Task<ButtonStatus> GetButtonStatus(bool isConnectTest = false)
        {
            try
            {
                var result = await EvApi.GetButtonStatus();
                LogWriter.Log($"Get respone : {result.Response}", isDebugLog: true);
                return result.Result;
            }
            catch (Exception e)
            {
                if (!isConnectTest)
                {
                    Error = ErrorType.GetStatusFail;
                    LogWriter.Log("Get Button Status Failed", isError: true);
                    LogWriter.Log(e.Message, isDebugLog: true);
                }
            }

            return null;
        }

        private string GetBtnStatusString(int? status)
        {
            switch (status)
            {
                case 1:
                    return "Pressed";
                case 0:
                    return "Unpressed";
                case null:
                    return "Unknown";
                default:
                    return status.ToString();
            }
        }

        private void ShowDialog(string msg, string title, string btnText, string imgUrl, bool cancelAble)
        {
            hintDialog = new HintDialog();

            hintDialog.Owner = Application.Current.MainWindow;

            hintDialog.Message = msg;
            hintDialog.Title = title;
            hintDialog.IsCancelAble = cancelAble;
            hintDialog.BtnText = btnText;
            hintDialog.ImgPath = imgUrl;

            if (cancelAble)
            {
                hintDialog.ShowDialog();
            }
            else
            {
                hintDialog.Show();
            }
        }

        private void DismisDialog()
        {
            if (hintDialog == null)
                return;
            hintDialog.Close();
        }

        private void UpdateButtonNeedTestVar()
        {
            isBtn1NeedTest = false; 
            isBtn2NeedTest = false; 
            isBtn3NeedTest = false; 
            isEmergencyNeedTest = false;

            switch (UpdateData.ButtonTestMode)
            {
                case ButtonTestModeType.TwoButtonsWithEmergencyButton:
                    isBtn1NeedTest = true;
                    isBtn2NeedTest = true;
                    isEmergencyNeedTest= true;
                    break;
                case ButtonTestModeType.SkipButtonTest:
                    break;
                case ButtonTestModeType.EmergencyButtonOnly:
                    isEmergencyNeedTest = true;
                    break;
                case ButtonTestModeType.TwoButtons:
                    isBtn1NeedTest = true;
                    isBtn2NeedTest = true;
                    break;
                case ButtonTestModeType.ThreeButtonsWithEmergencyButton:
                    isBtn1NeedTest = true;
                    isBtn2NeedTest = true;
                    isBtn3NeedTest= true;
                    isEmergencyNeedTest = true;
                    break;
            }
        }

        private bool IsAnyButtonPressed(ButtonStatus pressStatus)
        {
            return 
                (isBtn1NeedTest && pressStatus.Button1 == 1) ||
                (isBtn2NeedTest && pressStatus.Button2 == 1) ||
                (isEmergencyNeedTest && pressStatus.EmergencyButton == 1) ||
                (isBtn3NeedTest && pressStatus.Button3 == 1);
        }
    }
}