DC_Initlizer/AwInitilizer/Procedure/ButtonStatusCheckPorcedure.cs

using AwInitilizer.Assist;
using AwInitilizer.Model;
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.Windows;

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

    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();
        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;
            }

            //await PressBtnCheck(0);
            //DismisDialog();
            //await PressBtnCheck(1);
            //DismisDialog();
            //await PressBtnCheck(2);
            //DismisDialog();

            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,EmergencyButton in order 0,1,2
            for (int testType = 0; testType < 3; testType++)
            {
                if ((testType == 1 || testType == 0) &&
                    UpdateData.ButtonTestMode == ButtonTestModeType.SkipNormalButton)
                {
                    continue;
                }

                if (testType == 2 &&
                    UpdateData.ButtonTestMode == ButtonTestModeType.SkipEmergencyButton)
                {
                    continue;
                }

                var checkResult = await PressBtnCheck(testType);
                if (!checkResult)
                {
                    if (testType == 0)
                        Error = ErrorType.FirstButtonCheckFail;
                    else if (testType == 1)
                        Error = ErrorType.SecondButtonCheckFail;
                    else if (testType == 2)
                        Error = ErrorType.EmergencyButtonCheckFail;
                    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}, Expect:000",
                status.Button1, status.Button2, status.EmergencyButton));

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

            bool isAllMatched = true;
            if (status != null)
            {
                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipNormalButton)
                {
                    if (status.Button1 != 0)
                    {
                        Error = ErrorType.FirstButtonCheckFail;
                        LogWriter.Log("Button1 status ERROR, unpress is expected", isError: true);
                        //Logger.Print("Button1 status ERROR, unpress is expected", isError: true);
                        isAllMatched = false;
                    }
                    if (status.Button2 != 0)
                    {
                        Error = ErrorType.SecondButtonCheckFail;
                        LogWriter.Log("Button2 status ERROR, unpress is expected", isError: true);
                        //Logger.Print("Button2 status ERROR, unpress is expected", isError: true);
                        isAllMatched = false;
                    }
                }

                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipEmergencyButton)
                {
                    if (status.EmergencyButton != 0)
                    {
                        Error = ErrorType.EmergencyButtonCheckFail;
                        LogWriter.Log("EmergencyButton status ERROR, unpress is expected", isError: true);
                        //Logger.Print("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}", status.Button1, status.Button2, status.EmergencyButton));
                    return true;
                }
                else
                {
                    LogWriter.Report(LogEvent.UnpressButtonTest, string.Format("{0}{1}{2}", status.Button1, status.Button2, 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 == 2)
            {
                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},EmgerncyButton:{2}",
                    GetBtnStatusString(btnStatus.Button1),
                    GetBtnStatusString(btnStatus.Button2),
                    GetBtnStatusString(btnStatus.EmergencyButton)));

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

        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;
                }

                var isAnyButtonIsPressed = false;

                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipNormalButton)
                {
                    if (pressStatus.Button1 != 0 || pressStatus.Button2 != 0 )
                    {
                        isAnyButtonIsPressed = true;
                    }
                }

                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipEmergencyButton)
                {
                    if (pressStatus.EmergencyButton != 0)
                    {
                        isAnyButtonIsPressed = true;
                    }
                }

                //if any button is pressed
                //if (pressStatus.Button1 != 0 ||
                //    pressStatus.Button2 != 0 ||
                //    pressStatus.EmergencyButton != 0)
                if (isAnyButtonIsPressed)
                {
                    await WaitAllBtnRelease();
                    break;
                }
            }
            return pressStatus;
        }

        private bool CheckBtnStatus(int btnInt, ButtonStatus buttonStatus)
        {
            if (buttonStatus.Button1 == (btnInt == 0 ? 1 : 0) &&
                buttonStatus.Button2 == (btnInt == 1 ? 1 : 0) &&
                buttonStatus.EmergencyButton == (btnInt == 2 ? 1 : 0))
            {
                //Status correct
                return true;
            }
            else
            {
                return false;
            }
        }

        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 1:
                    btn = "Green Button";
                    btnLang = Resx.AppResources.BtnPressGreenBtn;
                    imgUrl = "pack://application:,,,/AwInitilizer;component/Image/Green.png";
                    break;
                case 0:
                    btn = "Blue Button";
                    btnLang = Resx.AppResources.BtnPressBlueBtn;
                    imgUrl = "pack://application:,,,/AwInitilizer;component/Image/Blue.png";
                    break;
                case 2:
                    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 status;
            //wait release
            for (var releaseCnt = 0; releaseCnt < 20; releaseCnt++)
            {
                await Task.Delay(500);
                status = await GetButtonStatus();
                if (status == null)
                {
                    //InfoLog += "Get Butoon state failed\n";
                    //Logger.Print("Get Butoon state failed");
                    continue;
                }

                bool isAllBtnReleased = true;

                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipNormalButton)
                {
                    if (status.Button1 != 0 || status.Button2 != 0)
                    {
                        isAllBtnReleased = false;
                    }
                }

                if (UpdateData.ButtonTestMode != ButtonTestModeType.SkipEmergencyButton)
                {
                    if (status.EmergencyButton != 0)
                    {
                        isAllBtnReleased = false;
                    }
                }

                //if (status.Button1 == 0 &&
                //    status.Button2 == 0 &&
                //    status.EmergencyButton == 0)
                if (isAllBtnReleased)
                {
                    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)
        {
            if (status == 1)
                return "Pressed";
            else if (status == 0)
                return "Unpressed";
            else
                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();
        }
    }
}