using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace Project
{
    public class CCustRule
    {
        public void Clear()
        {
            Code = string.Empty;
        }
        public string Code { get; set; }
        public string Name { get; set; }
        public int Len { get; set; }
        public string Pre { get; set; }
        public string Post { get; set; }
        public string Expression { get; set; }

        public Boolean isValid
        {
            get
            {
                return string.IsNullOrEmpty(Code) == false && Code.Equals("000") == false;
            }
        }
    }

    public class CResult
    {
        public enum eInspectResult
        {
            NG = 0,
            OK,
            ERROR,
            NOTSET = 9,
        }

        public DateTime ResetButtonDownTime = DateTime.Now;
        //public Class.VisionData[] VisionData = new Class.VisionData[3];
        public Boolean ClearAllSID = false;
        //public Class.CHistoryJOB JObHistory;
        public Class.CHistorySIDRef SIDReference;         //SIDLIST받은 내역
        public List<UIControl.CItem> OUTHistory;    //출고포트 처리내역
        public DataSet1.SIDHistoryDataTable SIDHistory; //sID별 rid 전체 목록 차수별로만 저장된다

        public DSList dsList;

        public ModelInfoM mModel;      //모션 모델 
        public ModelInfoV vModel;        //작업 모델

        /// <summary>
        /// 아이템의 정보가 담겨있다 (0:왼쪽,1:비젼,2:오른쪽)
        /// </summary>
        public Class.JobData[] ItemData = new Class.JobData[3];
        public string JobType2 = string.Empty;
        public Boolean JobFirst = false;
        public List<CCustRule> CustomerRule = new List<CCustRule>();

        public Boolean DryRun
        {
            get
            {
                if (string.IsNullOrEmpty(JobType2)) return false;
                else return JobType2.ToUpper() == "DRY";
            }
        }


        public int OverLoadCountF { get; set; }
        public int OverLoadCountR { get; set; }

        public UIControl.CItem UnloaderItem = null;
        public DateTime LastExtInputTime = DateTime.Parse("1982-11-23");
        public DateTime LastOutTime = DateTime.Parse("1982-11-23");

        public Single[] PortAlignWaitSec = new float[] { 0, 0, 0, 0 };
        public long[] PortAlignTime = new long[] { 0, 0, 0, 0 };

        public byte UnloaderSeq = 0;
        public DateTime UnloaderSeqTime;
        public DateTime UnloaderSendtime = DateTime.Parse("1982-11-23");



        //작업옵션처리  210121
        public Boolean Option_Confirm1 = false;
        public Boolean Option_QtyUpdate1 = false;
        public Boolean Option_QtyUpdateM = false;
        public Boolean Option_partUpdate = false;
        public Boolean Option_AutoConf = false;
        //public string Option_PrintPos1 = "";
        public Boolean Option_vname = false;
        public Boolean Option_NewReelID = false;
        //public bool Option_Dryrun = false;

        //public Boolean Option_Confirm3 = false;
        //public Boolean Option_QtyUpdate3 = false;
        //public Boolean Option_FixPrint3 = false;
        //public Boolean Option_printforce3 = false;
        //public string Option_PrintPos3 = "";


        /// <summary>
        /// 로딩에 사용하는 포트번호 (자동 판단됨)
        /// </summary>
        public int LoadPortIndex = -1;

        /// <summary>
        /// 로딩시에 사용한 포트의 번호(이 값으로 수량기록 위치를 결정)
        /// </summary>
        public int LoadPickIndex = -1;

        /// <summary>
        /// 최종 할당된 언로딩 포트번호(1~8)
        /// </summary>
        public int UnloadPortNo = -1;
        public byte LiveViewseq = 0;
        public string AcceptBcd = string.Empty;
        public DateTime AcceptBcdTime = DateTime.Now;
        public string AcceptSid = string.Empty;

        //작업정보
        public eInspectResult Result; //작업결과가 저장됨
        public eResult ResultCode;
        public string ResultMessage;

        public string LastSIDFrom = string.Empty;//101 = string.Empty;
        public string LastSIDTo = string.Empty; // 103 = string.Empty;
                                                //public string LastSID103_2 = string.Empty;
        public string LastVName = string.Empty;
        public int LastSIDCnt = 0;



        //작업정보(시간)
        public DateTime JobStartTime;
        public DateTime JobEndTime;
        public TimeSpan JobRunTime()
        {
            if (JobStartTime.Year == 1982) return new TimeSpan(0);
            if (JobEndTime.Year == 1982) return DateTime.Now - JobStartTime;
            else return JobEndTime - JobStartTime;
        }

        /// <summary>
        /// RUN -> Pause(Wait Start)모드 전환시 저장할 모터의 위치값
        /// 조그모드등으로 좌표를 옴길때의 기준 좌표
        /// 이 좌표값에서 현재 모션값에 변화가 있으면 프로그램에서는 오류로 처리하게 됨
        /// </summary>
        public double[] PreventMotionPosition = new double[8];

        #region "SetResultMessage"

        public void SetResultMessage(eResult code, eECode err, eNextStep systempause, params object[] args)
        {
            var msg = getResultCodeMessage(code) + " ERROR\n" + getErrorMessage(code, err, args);
            SetResultMessage(code, msg, systempause);
        }

        private void SetResultMessage(eResult code, string msg, eNextStep systemPause)
        {
            this.ResultCode = code;
            this.ResultMessage = msg;
            if (systemPause == eNextStep.pauseNoMessage) this.ResultMessage = string.Empty; //210129
            Pub.log.AddE(msg);
            if (systemPause == eNextStep.pause) Pub.sm.setNewStep(StateMachine.eSMStep.PAUSE);
            else if (systemPause == eNextStep.pauseNoMessage) Pub.sm.setNewStep(StateMachine.eSMStep.PAUSE);
            else if (systemPause == eNextStep.error) Pub.sm.setNewStep(StateMachine.eSMStep.ERROR);
        }

        //public void SetResultTimeOutMessage(StateMachine.eSMStep step, eNextStep systemPause)
        //{
        //    SetResultMessage(eResult.TIMEOUT, eECode.timeout_step, systemPause, step);
        //}
        public void SetResultTimeOutMessage(eDOName pinName, Boolean checkState, eNextStep systemPause)
        {
            if (checkState) SetResultMessage(eResult.SENSOR, eECode.doon, systemPause, pinName);
            else SetResultMessage(eResult.SENSOR, eECode.dooff, systemPause, pinName);
        }
        public void SetResultTimeOutMessage(eDIName pinName, Boolean checkState, eNextStep systemPause)
        {
            if (checkState) SetResultMessage(eResult.SENSOR, eECode.dion, systemPause, pinName);
            else SetResultMessage(eResult.SENSOR, eECode.dioff, systemPause, pinName);
        }
        public void SetResultTimeOutMessage(eAxis motAxis, eECode ecode, eNextStep systemPause, string source)
        {
            SetResultMessage(eResult.TIMEOUT, ecode, systemPause, motAxis, source);
        }
        public void SetResultTimeOutMessage(eECode ecode, eNextStep systemPause, params object[] args)
        {
            SetResultMessage(eResult.TIMEOUT, ecode, systemPause, args);
        }
        #endregion

        public DateTime[,] diCheckTime = new DateTime[2, 64];
        public DateTime[,] doCheckTime = new DateTime[2, 64];

        public Boolean isError { get; set; }
        // public Boolean isMarkingMode { get; set; }

        public int retry = 0;
        public DateTime retryTime;
        public DateTime[] WaitForVar = new DateTime[255];
        public int JoystickAxisGroup = 0;

        public int ABCount = 0;


        public CResult()
        {
            mModel = new ModelInfoM();
            vModel = new ModelInfoV();

            SIDReference = new Class.CHistorySIDRef();
            SIDHistory = new DataSet1.SIDHistoryDataTable();
            //JObHistory = new Class.CHistoryJOB();

            OUTHistory = new List<UIControl.CItem>();

            this.Clear();

            dsList = new DSList();
            LoadListDB();
        }

        public void SaveListDB()
        {
            var finame = System.IO.Path.Combine(Util.CurrentPath, "Data", "SavaedList.xml");
            var fi = new System.IO.FileInfo(finame);
            if (fi.Directory.Exists == false) fi.Directory.Create();
            this.dsList.WriteXml(fi.FullName);
            Pub.log.Add("사전목록DB를 저장 했습니다" + fi.FullName);
        }

        public void LoadListDB()
        {
            var finame = System.IO.Path.Combine(Util.CurrentPath, "Data", "SavaedList.xml");
            var fi = new System.IO.FileInfo(finame);
            if (fi.Directory.Exists == false) fi.Directory.Create();
            if (fi.Exists)
            {
                this.dsList.ReadXml(fi.FullName);
                Pub.log.Add("사전목록DB를 불러왔습니다" + fi.FullName);
            }
        }

        /// <summary>
        /// 입력한 sid 가 원본에 존재하지 않으면 -1을 존재하면 입력된 수량을 반환합니다
        /// </summary>
        /// <param name="sid"></param>
        /// <returns></returns>
        public int ExistSIDReferenceCheck(string sid)
        {
            var dr = Pub.Result.SIDReference.Items.Where(t => t.sid.EndsWith(sid)).FirstOrDefault();
            if (dr == null) return -1;
            else return dr.kpc;
        }


        public void ClearHistory()
        {

            //this.JObHistory.Clear();
            this.SIDReference.Clear();
            Pub.log.AddI("Clear History");
        }


        public void ClearOutPort()
        {
            OUTHistory.Clear();
        }

        public void Clear()
        {
            //this.JObHistory.Clear();
            this.ItemData = new Class.JobData[3];
            for (int i = 0; i < ItemData.Length; i++)
            {
                ItemData[i] = new Class.JobData(i);
            }
            JobFirst = true;
            OverLoadCountF = 0;
            OverLoadCountR = 0;
            ClearOutPort();

            LoadPortIndex = -1;

            Pub.ClearRunStepSeqTime();

            isError = false;
            ABCount = 0;
            ///기다림용 변수모듬
            for (int i = 0; i < WaitForVar.Length; i++)
                WaitForVar[i] = DateTime.Parse("1982-11-23");

            //조그모드시 모션이동 감지용 저장 변수
            for (int i = 0; i < 6; i++)
                PreventMotionPosition[i] = 0.0;

            JobStartTime = DateTime.Parse("1982-11-23");
            JobEndTime = DateTime.Parse("1982-11-23");
            LastOutTime = DateTime.Parse("1982-11-23");

            Result = eInspectResult.NOTSET;
            ResultCode = eResult.NOERROR;
            ResultMessage = string.Empty;

            //시간정보값을 초기화함
            for (int i = 0; i < 2; i++)
                ClearTime(i);

            Pub.log.Add("Result 데이터 초기화");
        }


        public void ClearTime(int shutIdx)
        {
            JobStartTime = DateTime.Parse("1982-11-23");
            JobEndTime = DateTime.Parse("1982-11-23");

            Result = eInspectResult.NOTSET;
            ResultCode = eResult.NOERROR;
            ResultMessage = string.Empty;

            Pub.log.Add("Result(Clear Time)");
        }

        public Boolean isSetmModel
        {
            get
            {
                if (Pub.Result.mModel == null || Pub.Result.mModel.idx == -1 || Pub.Result.mModel.Title.isEmpty())
                    return false;
                else return true;
            }

        }
        public Boolean isSetvModel
        {
            get
            {
                if (Pub.Result.vModel == null || Pub.Result.vModel.idx == -1 || Pub.Result.vModel.Title.isEmpty())
                    return false;
                else return true;
            }

        }
        public string getErrorMessage(eResult rlt, eECode err, params object[] args)
        {
            switch (err)
            {

                case eECode.DOORF:
                    return string.Format("전면 도어가 열렸습니다");
                case eECode.DOORR:
                    return string.Format("후면 도어가 열렸습니다");
                case eECode.SIDERR101:
                    return string.Format("현재 작업 형태와 SID값이 일치하지 않습니다\nSID:{0}\n작업형태:{1}\n101 SID작업 입니다.", args);
                case eECode.SIDERR106:
                    return string.Format("현재 작업 형태와 SID값이 일치하지 않습니다\nSID:{0}\n작업형태:{1}\n106 SID작업 입니다.", args);
                case eECode.SIDERR103:
                    return string.Format("현재 작업 형태와 SID값이 일치하지 않습니다\nSID:{0}\n작업형태:{1}\n103 SID작업 입니다.", args);
                case eECode.RIDDUPL:
                    return string.Format(
                        "좌측 언로더에 사용되었던 REEL ID 입니다\n" +
                        "바코드 오류 가능성이 있습니다\n" +
                        "좌측 릴의 바코드를 확인하시기 바랍니다\n" +
                        "작업을 계속할 수 없습니다. 취소 후 다시 시도하세요\n{0}", args);


                case eECode.RIDDUPR:
                    return string.Format(
                        "우측 언로더에 사용되었던 REEL ID 입니다\n" +
                        "바코드 오류 가능성이 있습니다\n" +
                        "우측 릴의 바코드를 확인하시기 바랍니다\n" +
                        "작업을 계속할 수 없습니다. 취소 후 다시 시도하세요\n{0}", args);

                case eECode.BARCODEVALIDERR:
                    return string.Format("바코드 데이터 검증 실패\n" +
                        "인쇄전 데이터와 인쇄후 데이터가 일치하지 않습니다\n" +
                        "ID(O) : {1}\n" +
                        "ID(N) : {2}\n" +
                        "SID : {5}->{6}\n" +
                        "QTY : {3}->{4}\n" +
                        "DATE : {7}->{8}\n" +
                        "Index : {0}", args);

                case eECode.MOTX_SAFETY:
                    return string.Format("PICKER-X 축이 안전위치에 없습니다\n1. 조그를 이용하여 중앙으로 이동 합니다\n2.홈 작업을 다시 실행합니다", args);
                case eECode.noerror:
                    return string.Format("오류가 없습니다", args);

                case eECode.portoverload:
                    return string.Format("PORT OVERLOAD\n위치 : {0}\n" +
                    "너무 많은 양이 적재 되었습니다\n" + "상단 LIMIT 센서에 걸리지 않게 적재하세요", args);
                case eECode.emergency:
                    return string.Format("비상정지 버튼을 확인하세요\n" +
                        "버튼 : F{0}\n" +
                        "메인전원이 OFF 된 경우에도 이 메세지가 표시 됩니다\n" +
                        "메인전원은 모니터 하단 AIR버튼 좌측에 있습니다"
                        , Util_DO.GetIOInput(eDIName.BUT_EMGF));
                case eECode.nomodelm:
                    return "모션모델이 선택되지 않았습니다\n" +
                     "상단 메뉴 [모션모델]에서 사용할 모델을 선택하세요";
                case eECode.nomodelv:
                    return "작업모델이 선택되지 않았습니다\n" +
                     "상단 메뉴 [작업모델]에서 사용할 모델을 선택하세요";

                case eECode.CARTERROR:
                    return string.Format("언로더 카트가 없거나 크기 정보가 일치하지 않습니다\n좌측:{0}, 로더:{1}, 우측:{2}", args);
                case eECode.CARTL:
                    return string.Format("왼쪽(UNLOAD) 포트에 카트가 감지되지 않습니다\n카트를 장착하세요\n카트크기 : {0}, 릴크기:{1}", args);
                case eECode.CARTC:
                    return string.Format("중앙(LOAD) 포트에 카트가 감지되지 않습니다\n카트를 장착하세요\n카트크기 : {0}, 릴크기:{1}", args);
                case eECode.CARTR:
                    return string.Format("오른쪽(UNLOAD) 포트에 카트가 감지되지 않습니다\n카트를 장착하세요\n카트크기 : {0}, 릴크기:{1}", args);

                case eECode.CARTLMATCH:
                    return string.Format("왼쪽(UNLOAD) 카트와 피커의 릴 크기가 일치하지 않습니다\n카트크기를 확인 하세요\n카트크기 : {0}, 릴크기:{1}", args);
                case eECode.CARTCMATCH:
                    return string.Format("중앙(LOAD) 카트와 피커의 릴 크기가 일치하지 않습니다\n카트크기를 확인 하세요\n카트크기 : {0}, 릴크기:{1}", args);
                case eECode.CARTRMATCH:
                    return string.Format("오른쪽(UNLOAD) 카트와 피커의 릴 크기가 일치하지 않습니다\n카트크기를 확인 하세요\n카트크기 : {0}, 릴크기:{1}", args);


                case eECode.NOREELSIZEL:
                    return string.Format("왼쪽포트에 놓을 릴의 크기정보가 없습니다\n프로그램 오류입니다\n개발자에게 해당 메세지를 전달하세요\n" +
                        "장치 초기화를 진행 한 후 다시 시도하세요");

                case eECode.NOREELSIZER:
                    return string.Format("오른쪽포트에 놓을 릴의 크기정보가 없습니다\n프로그램 오류입니다\n개발자에게 해당 메세지를 전달하세요\n" +
                        "장치 초기화를 진행 한 후 다시 시도하세요");

                case eECode.CAM_CONN:
                    return string.Format("카메라({0}) 연결 안됨", args);

                case eECode.EVISION_CONN:
                    return string.Format("E-Vision USB Dongle Error", args);
                case eECode.CAM_NOBARCODEL:
                    return string.Format("로더 바코드 필수값을 읽지 못했습니다", args);
                case eECode.CAM_NOBARCODEU:
                    return string.Format("언로더({0}) 바코드를 읽지 못했습니다", args);
                case eECode.HOME_TIMEOUT:
                    return string.Format("홈 진행이 완료되지 않고 있습니다\n" +
                        "오류가 발생했다면 '홈' 작업을 다시 진행하세요\n" +
                        "대기시간 : {0}초", args);

                case eECode.PICKOVL:
                    return string.Format("피커({0})에서 오버로드가 감지되었습니다\n" +
                "센서및 포트의 적재 상태를 확인한 후 다시 시도하세요", args);

                case eECode.saftyport:
                    return string.Format("포트 안전센서가 감지 되었습니다\n" +
                        "안전센서를 확인한 후 다시 시도하세요\n", args);

                case eECode.airnoout:
                    return "AIR 공급이 차단 되어 있습니다.\n" +
                        "전면의 AIR 버튼을 누르세요\n" +
                        "공급이 되지 않으면 메인 전원 을 확인하세요\n" +
                        "메인 전원은 AIR 버튼 좌측에 있습니다" +
                        "메인 전원 공급 실패시 장비 후면의 차단기를 확인하세요";


                case eECode.dooff:
                    var pinoOf = (eDOName)args[0];
                    return string.Format("출력이 OFF 되지 않았습니다.\n" +
                       "포트설명 : {0}\n" +
                       "포트번호 : {1} ({2})", Util_DO.getPinDescription(pinoOf), (int)pinoOf, Enum.GetName(typeof(eDOPin), pinoOf));
                case eECode.doon:
                    var pinoOn = (eDOName)args[0];
                    return string.Format("출력이 ON 되지 않았습니다.\n" +
                       "포트설명 : {0}\n" +
                       "포트번호 : {1} ({2})", Util_DO.getPinDescription(pinoOn), (int)pinoOn, Enum.GetName(typeof(eDOPin), pinoOn));
                case eECode.dioff:
                    var piniOf = (eDIName)args[0];
                    return string.Format("입력이 OFF 되지 않았습니다.\n" +
                       "포트설명 : {0}\n" +
                       "포트번호 : {1} ({2})", Util_DO.getPinDescription(piniOf), (int)piniOf, Enum.GetName(typeof(eDIPin), piniOf));
                case eECode.dion:
                    var piniOn = (eDIName)args[0];
                    return string.Format("입력이 ON 되지 않았습니다.\n" +
                        "포트설명 : {0}\n" +
                        "포트번호 : {1} ({2})", Util_DO.getPinDescription(piniOn), (int)piniOn, Enum.GetName(typeof(eDIPin), piniOn));

                case eECode.azininit:
                    return string.Format("DIO 혹은 모션카드가 초기화 되지 않았습니다.\n" +
                 "DIO    : {0}\n" +
                 "MOTION : {1}\n" +
                 "해당 카드는 본체 내부 PCI 슬롯에 장착 된 장비 입니다\n" +
                 "EzConfig AXT 프로그램으로 카드 상태를 확인하세요",
                 Pub.dio.IsInit, Pub.mot.IsInit);


                case eECode.MOT_INIT:
                    return string.Format("모션카드가 초기화 되지 않았습니다\n" +
                        "아진엑스텍 프로그램을 통해서 보드를 확인하세요\n" +
                        "PC를 재부팅한 후 재시도 하세요", args);

                case eECode.MOT_HSET:
                    var msg = "모션의 HOME 검색이 완료되지 않았습니다";
                    for (int i = 0; i < 6; i++)
                    {
                        if (Pub.mot.isUse[i] == false) continue;
                        var axis = (eAxis)i;
                        var stat = Pub.mot.isHomeSet[i];
                        if (stat == false) msg += string.Format("\n[{0}] {1} : {2}", i, axis, stat);
                    }
                    msg += "\n장치 초기화를 실행하세요";
                    return msg;
                case eECode.MOT_SVOFF:
                    var msgsv = "모션 중 SERVO-OFF 된 축이 있습니다";
                    for (int i = 0; i < 6; i++)
                    {
                        if (Pub.mot.isUse[i] == false) continue;
                        var axis = (eAxis)i;
                        var stat = Pub.mot.isSERVOON[i];
                        if (stat == false) msgsv += string.Format("\n[{0}] {1} : {2}", i, axis, stat);
                    }
                    msgsv += "\nRESET을 누른 후 '모션설정' 화면에서 확인합니다";
                    return msgsv;
                case eECode.MOT_HSEARCH:
                    return string.Format("모션의 홈 검색이 실패되었습니다\n" +
                                         "축 : {0}\n" +
                                         "메세지 : {1}", args);

                case eECode.MOT_CMD:
                    var axisNo = (int)((eAxis)args[0]);
                    var axisSrc = args[1].ToString();
                    return string.Format("모션축 명령이 실패 되었습니다\n축 : {0}\n" +
                        "현재위치 : {2}\n" +
                        "명령위치 : {3}\n" +
                        "소스 : {1}", axisNo, axisSrc, Pub.mot.dACTPOS[axisNo], Pub.mot.dCMDPOS[axisNo]);

                case eECode.MNBR:
                    return string.Format("MNBR 값이 없습니다\n" +
                    "환경설정에서 MNBR 값을 입력하세요", args);

                //case eECode.timeout_step:
                //    return string.Format("스텝당 최대 실행 시간이 초과 되었습니다.\n" +
                //             "스텝 : {0}\n" +
                //             "최대동작시간 : " + Pub.setting.Timeout_StepMaxTime.ToString(), args);


                case eECode.USER_STOP:
                    return "'일시정지' 버튼 눌림\n" +
                  "사용자에 의해 작동이 중지 되었습니다\n" +
                  "'RESET' -> 'START'로 작업을 계속할 수 있습니다";

                case eECode.CAM_RIGHT:
                    return "우측카메라가 사용가능한 상태가 아닙니다.\n" +
                        "신규 실행시에는 초기화 완료까지 기다려 주세요";
                case eECode.CAM_LEFT:
                    return "좌측카메라가 사용가능한 상태가 아닙니다.\n" +
                        "신규 실행시에는 초기화 완료까지 기다려 주세요";
                default:
                    return err.ToString();
            }

        }
        public string getResultCodeMessage(eResult rltCode)
        {
            //별도 메세지처리없이 그대로 노출한다
            return rltCode.ToString().ToUpper();
        }

    }

}