using SA_LTT;
using SA_LTT.Module;
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Excel = Microsoft.Office.Interop.Excel;

namespace SA_LTT_UI.Viewer
{
    public partial class ScannerViewer : Form
    {
        MainFrame _mainFrame;
        Thread t_UIUpdate;
        Scanner scanner;

        object _lockObject = new object();

        bool updateCheck;

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams MyCp = base.CreateParams;
                MyCp.ExStyle |= 0x02000000;

                return MyCp;
            }
        }

        delegate void ScanListAddDelegate(Coord coord);
        public ScannerViewer(MainFrame mainFrame)
        {
            InitializeComponent();
            _mainFrame = mainFrame;
            cbb_ScanMode.SelectedIndex = 0;

            scanner = new Scanner();

            _mainFrame.equipment.scanner.ScanListAdded += Scanner_ScanListAdded;
            _mainFrame.equipment.scanner.ScanListCleared += Scanner_ScanListCleared;

            t_UIUpdate = new Thread(UIUpdateTh);
            t_UIUpdate.Start();

            SettingRefresh();
        }

        private void SettingRefresh()
        {
            scanner.Copy(_mainFrame.equipment.scanner);
            tb_CorrectionFilePath.Text = $"{scanner.CorrectionFilePath}";
            tb_EncoderCountPerMmX.Text = $"{scanner.EncoderCountPerMmX}";
            tb_EncoderCountPerMmY.Text = $"{scanner.EncoderCountPerMmY}";
            tb_BitsPerMm.Text = $"{scanner.BitsPerMm}";
            tb_FOV.Text = $"{scanner.FOV}";

            tb_HalfPeriod.Text = $"{scanner.HalfPeriod}";
            tb_PulseLength.Text = $"{scanner.PulseLength1}";
            tb_LaserOnDelay.Text = $"{scanner.LaserOnDelay}";
            tb_LaserOffDelay.Text = $"{scanner.LaserOffDelay}";

            tb_JumpDelay.Text = $"{scanner.JumpDelay}";
            tb_MarkDelay.Text = $"{scanner.MarkDelay}";
            tb_PolygonDelay.Text = $"{scanner.PolygonDelay}";
        }

        private void Scanner_ScanListAdded(Coord coord)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new ScanListAddDelegate(Scanner_ScanListAdded), coord);
                return;
            }
            else
            {
                lock (_lockObject)
                {
                    ListViewItem lvi = new ListViewItem(lv_ScanList.Items.Count.ToString());
                    lvi.SubItems.Add(coord.ScanMode.ToString());
                    lvi.SubItems.Add((coord.X / scanner.BitsPerMm).ToString("f3"));
                    lvi.SubItems.Add((coord.Y / scanner.BitsPerMm).ToString("f3"));
                    lv_ScanList.Items.Add(lvi);
                }
            }
        }

        private void Scanner_ScanListCleared()
        {
            if (InvokeRequired)
            {
                BeginInvoke(new ScanListCleared(Scanner_ScanListCleared));
                return;
            }
            else
            {
                lock (_lockObject)
                {
                    lv_ScanList.Items.Clear();
                }
            }
        }

        private void UIUpdateTh()
        {
            while (_mainFrame.equipment.IsDisposed == false)
            {
                Thread.Sleep(10);

                if (updateCheck == false)
                {
                    updateCheck = true;
                    UIUpdate();
                }
            }
        }

        private void UIUpdate()
        {
            if (InvokeRequired)
            {
                BeginInvoke(new UIUpdateDelegate(UIUpdate));
                return;
            }
            else
            {
                try
                {
                    tb_ProcessPosition.Text = _mainFrame.equipment.scanner.IsPosition.ToString();
                    tb_BitsPerMm.Text = scanner.BitsPerMm.ToString();

                    lb_Initialized.BackColor = _mainFrame.equipment.scanner.IsInitialized ? System.Drawing.Color.Lime : System.Drawing.Color.Red;
                    lb_Busy.BackColor = _mainFrame.equipment.scanner.IsBusy ? System.Drawing.Color.Lime : System.Drawing.Color.Red;

                    tb_CorrectionFilePath.BackColor = scanner.CorrectionFilePath == _mainFrame.equipment.scanner.CorrectionFilePath ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_EncoderCountPerMmX.BackColor = scanner.EncoderCountPerMmX == _mainFrame.equipment.scanner.EncoderCountPerMmX ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_EncoderCountPerMmY.BackColor = scanner.EncoderCountPerMmY == _mainFrame.equipment.scanner.EncoderCountPerMmY ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_BitsPerMm.BackColor = scanner.BitsPerMm == _mainFrame.equipment.scanner.BitsPerMm ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_FOV.BackColor = scanner.FOV == _mainFrame.equipment.scanner.FOV ? System.Drawing.Color.White : System.Drawing.Color.Red;

                    tb_HalfPeriod.BackColor = scanner.HalfPeriod == _mainFrame.equipment.scanner.HalfPeriod ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_PulseLength.BackColor = scanner.PulseLength1 == _mainFrame.equipment.scanner.PulseLength1 ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_LaserOnDelay.BackColor = scanner.LaserOnDelay == _mainFrame.equipment.scanner.LaserOnDelay ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_LaserOffDelay.BackColor = scanner.LaserOffDelay == _mainFrame.equipment.scanner.LaserOffDelay ? System.Drawing.Color.White : System.Drawing.Color.Red;

                    tb_JumpDelay.BackColor = scanner.JumpDelay == _mainFrame.equipment.scanner.JumpDelay ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_MarkDelay.BackColor = scanner.MarkDelay == _mainFrame.equipment.scanner.MarkDelay ? System.Drawing.Color.White : System.Drawing.Color.Red;
                    tb_PolygonDelay.BackColor = scanner.PolygonDelay == _mainFrame.equipment.scanner.PolygonDelay ? System.Drawing.Color.White : System.Drawing.Color.Red;

                    btn_LaserOn.BackColor = _mainFrame.equipment.scanner.IsLaserOn ? System.Drawing.Color.Lime : System.Drawing.Color.Red;
                    btn_LaserOff.BackColor = !_mainFrame.equipment.scanner.IsLaserOn ? System.Drawing.Color.Lime : System.Drawing.Color.Red;
                }
                catch (Exception e)
                {
                    EquipmentLogManager.Instance.WriteExceptionLog(e.StackTrace);
                }
                finally
                {
                    updateCheck = false;
                }
            }
        }

        private void SettingData_Leave(object sender, EventArgs e)
        {
            SetSettingData(sender);
        }

        private void SettingData_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == Keys.Enter)
            {
                SetSettingData(sender);
            }
        }

        private void SetSettingData(object sender)
        {
            TextBox textBox = (TextBox)sender;
            double doubleData;
            int intData;
            uint uintData;

            switch (textBox.Name)
            {
                case "tb_CorrectionFilePath":
                    {
                        scanner.CorrectionFilePath = tb_CorrectionFilePath.Text;
                        break;
                    }
                case "tb_EncoderCountPerMmX":
                    {
                        int.TryParse(tb_EncoderCountPerMmX.Text, out intData);
                        scanner.EncoderCountPerMmX = intData;
                        textBox.Text = $"{intData}";
                        break;
                    }
                case "tb_EncoderCountPerMmY":
                    {
                        int.TryParse(tb_EncoderCountPerMmY.Text, out intData);
                        scanner.EncoderCountPerMmY = intData;
                        textBox.Text = $"{intData}";
                        break;
                    }
                case "tb_FOV":
                    {
                        double.TryParse(tb_FOV.Text, out doubleData);
                        scanner.FOV = doubleData;
                        textBox.Text = $"{doubleData}";
                        break;
                    }
                case "tb_HalfPeriod":
                    {
                        uint.TryParse(tb_HalfPeriod.Text, out uintData);
                        scanner.HalfPeriod = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
                case "tb_PulseLength":
                    {
                        uint.TryParse(tb_PulseLength.Text, out uintData);
                        scanner.PulseLength1 = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
                case "tb_LaserOnDelay":
                    {
                        int.TryParse(tb_LaserOnDelay.Text, out intData);
                        scanner.LaserOnDelay = intData;
                        textBox.Text = $"{intData}";
                        break;
                    }
                case "tb_LaserOffDelay":
                    {
                        uint.TryParse(tb_LaserOffDelay.Text, out uintData);
                        scanner.LaserOffDelay = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
                case "tb_JumpDelay":
                    {
                        uint.TryParse(tb_JumpDelay.Text, out uintData);
                        scanner.JumpDelay = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
                case "tb_MarkDelay":
                    {
                        uint.TryParse(tb_MarkDelay.Text, out uintData);
                        scanner.MarkDelay = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
                case "tb_PolygonDelay":
                    {
                        uint.TryParse(tb_PolygonDelay.Text, out uintData);
                        scanner.PolygonDelay = uintData;
                        textBox.Text = $"{uintData}";
                        break;
                    }
            }
        }

        private void btn_GetEncoder_Click(object sender, EventArgs e)
        {
            if (_mainFrame.equipment.scanner.GetEncoder())
            {
                tb_Encoder0.Text = _mainFrame.equipment.scanner.Encoder0.ToString();
                tb_Encoder1.Text = _mainFrame.equipment.scanner.Encoder1.ToString();
            }
        }

        private void btn_Add_Click(object sender, EventArgs e)
        {
            ScanMode scanmode = (ScanMode)cbb_ScanMode.SelectedIndex;

            double posX;
            double posY;
            double.TryParse(tb_PosX.Text, out posX);
            double.TryParse(tb_PosY.Text, out posY);

            _mainFrame.equipment.scanner.AddScanList(scanmode, posX, posY);
        }

        private void btn_Clear_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.ClearScanList();
        }

        private void btn_Run_Click(object sender, EventArgs e)
        {
            double markSpeed;
            double jumpSpeed;

            double.TryParse(tb_MarkSpeed.Text, out markSpeed);
            double.TryParse(tb_JumpSpeed.Text, out jumpSpeed);

            _mainFrame.equipment.scanner.SetScannerDelay();
            _mainFrame.equipment.scanner.SetLaserTiming();
            _mainFrame.equipment.scanner.SetLaserDelays();
            _mainFrame.equipment.scanner.SetJumpMarkSpeed(jumpSpeed, markSpeed);
            _mainFrame.equipment.scanner.ExcuteScanList();
        }

        private void btn_Stop_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.Stop();
        }

        private void btn_Cancel_Click(object sender, EventArgs e)
        {
            SettingRefresh();
        }

        private void btn_Save_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.Copy(scanner);
            _mainFrame.equipment.scanner.Save();
        }

        private void ScannerViewer_FormClosing(object sender, FormClosingEventArgs e)
        {
            e.Cancel = true;
            this.Hide();
        }

        private void lb_Initialized_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.Initialize();
        }

        private void btn_LaserOn_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.LaserOn();
        }

        private void btn_LaserOff_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.LaserOff();
        }

        private void btn_AddScanField_Click(object sender, EventArgs e)
        {
            _mainFrame.equipment.scanner.ClearScanList();

            int lineCount = (int)nud_LineCount.Value;
            double fieldSize = 0;

            if(double.TryParse(tb_FieldSize.Text, out fieldSize))
            {
                _mainFrame.equipment.scanner.AddScanField(lineCount, fieldSize);
            }
        }

        //오래걸림 스레드로 돌려야 될지도 ..?
        private void SaveScanFieldExcel(int lineCount, double fieldSize)
        {
            try
            {
                var excelApp = new Excel.Application();
                excelApp.Visible = false;
                
                Excel.Workbook workBook = excelApp.Workbooks.Add();
                
                workBook.Worksheets.Add();
                Excel._Worksheet workSheet = workBook.Worksheets.get_Item(1) as Excel.Worksheet;

                double lineMax = fieldSize / 2;
                double lineMin = -(fieldSize / 2);

                double intervalLength = fieldSize / (lineCount - 1);
                intervalLength = double.Parse(intervalLength.ToString("F3"));

                List<int> bitsX = new List<int>();
                List<int> bitsY = new List<int>();

                List<double> positionsX = new List<double>();
                List<double> positionsY = new List<double>();

                for (int i = -(lineCount - 1) / 2; i <= (lineCount - 1) / 2; i++)
                {
                    bitsX.Add((int)Math.Floor((intervalLength * i) * _mainFrame.equipment.scanner.BitsPerMm));
                    bitsY.Add((int)Math.Floor(-(intervalLength * i) * _mainFrame.equipment.scanner.BitsPerMm));
                    positionsX.Add(intervalLength * i);
                    positionsY.Add(-intervalLength * i);
                }

                for (int i = 0; i < lineCount; i++)
                {
                    for (int j = 0; j < lineCount; j++)
                    {
                        workSheet.Cells[1 + (i * 4), 1 + (j * 2)] = bitsX[j];
                        workSheet.Cells[1 + (i * 4), 2 + (j * 2)] = bitsY[i];

                        workSheet.Cells[2 + (i * 4), 1 + (j * 2)] = positionsX[j];
                        workSheet.Cells[2 + (i * 4), 2 + (j * 2)] = positionsY[i];

                        workSheet.Cells[3 + (i * 4), 1 + (j * 2)] = "";
                        workSheet.Cells[3 + (i * 4), 2 + (j * 2)] = "";

                        workSheet.Cells[3 + (i * 4), 1 + (j * 2)].Interior.Color = System.Drawing.Color.PaleGreen;
                        workSheet.Cells[3 + (i * 4), 2 + (j * 2)].Interior.Color = System.Drawing.Color.PaleGreen;

                        workSheet.Cells[4 + (i * 4), 1 + (j * 2)] = $"= {(char)(65 + (j * 2))}{2 + (i * 4)} - {(char)(65 + (j * 2))}{3 + (i * 4)} ";
                        workSheet.Cells[4 + (i * 4), 2 + (j * 2)] = $"= {(char)(66 + (j * 2))}{2 + (i * 4)} - {(char)(66 + (j * 2))}{3 + (i * 4)} ";
                    }
                }

                workSheet.Columns[1].AutoFit();
                workSheet.Columns[2].AutoFit();

                workBook.SaveAs(@"D:\ScannerField.xls");
                //workBook.Save();
                workBook.Close(true, System.Reflection.Missing.Value, System.Reflection.Missing.Value);
                excelApp.Quit();

                Marshal.ReleaseComObject(workSheet);
                Marshal.ReleaseComObject(workBook);
                Marshal.ReleaseComObject(excelApp);
            }
            catch (Exception ex)
            {
                MessageBoxPad mbp = new MessageBoxPad("Excel 쓰기 실패" + ex.Message);
                mbp.Show();
            }
        }

        private void ReadScanFieldExcel(int lineCount, string filePath = @"D:\ScannerField.xls")
        {
            try
            {
                List<string[]> result = new List<string[]>();

                DateTime dt = DateTime.Now;
                StringBuilder sb = new StringBuilder();
                sb.Clear();
                sb.AppendLine($"OLDCTFILE = Cor_1to1.ct5");
                sb.AppendLine($"NEWCTFILE = Correction_{dt.ToString("HH_mm")}.ct5");
                sb.AppendLine($"TOLERANCE = 0");
                sb.AppendLine($"NEWCAL = {_mainFrame.equipment.scanner.BitsPerMm}");
                sb.AppendLine("LIMITS");
                var excelApp = new Excel.Application();
                excelApp.Visible = false;

                Excel.Workbook workBook = excelApp.Workbooks.Open(filePath);

                Excel._Worksheet workSheet = workBook.Worksheets.get_Item(1) as Excel.Worksheet;

                Excel.Range range = workSheet.UsedRange;

                object[,] data = (object[,])range.Value;

                for (int row = 1; row <= data.GetLength(0); row += 4)
                {
                    int length = data.GetLength(1);
                    string[] arr = new string[lineCount];

                    for (int column = 1; column <= length; column += 2)
                    {
                        double xbit = double.Parse($"{data[row, column]:F3}");
                        double ybit = double.Parse($"{data[row, column + 1]:F3}");
                        double xdata = double.Parse($"{data[row + 2, column] :F3}");
                        double ydata= double.Parse($"{data[row + 2, column + 1]:F3}");

                        sb.AppendLine($"{xbit} {ybit} {xdata} {ydata}");
                    }
                }

                workBook.Close();
                excelApp.Quit();

                Marshal.ReleaseComObject(workSheet);
                Marshal.ReleaseComObject(workBook);
                Marshal.ReleaseComObject(excelApp);

                using (FileStream fs = new FileStream($@"D:\Correction_{dt.ToString("HH_mm")}.ct5.dat", FileMode.Create))
                {
                    using (StreamWriter sw = new StreamWriter(fs, Encoding.GetEncoding("ks_c_5601-1987")))
                    {
                        sw.Write(sb);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBoxPad mbp = new MessageBoxPad("Excel 변환 실패" + ex.Message);
                mbp.Show();
            }
        }

        private void btn_Shot_Click(object sender, EventArgs e)
        {
            Thread laserOffThread = new Thread(LaserOff);
            laserOffThread.Start();
        }
        
        private void LaserOff()
        {
            int laserShotTime = (int)nud_LaserShotTime.Value;
            _mainFrame.equipment.scanner.LaserOn();
            Thread.Sleep(laserShotTime);
            _mainFrame.equipment.scanner.LaserOff();
        }

        private void btn_WriteExcel_Click(object sender, EventArgs e)
        {
            int lineCount = (int)nud_LineCount.Value;
            double fieldSize = 0;

            if (double.TryParse(tb_FieldSize.Text, out fieldSize))
            {
                SaveScanFieldExcel(lineCount, fieldSize);
            }
        }

        private void btn_ReadExcel_Click(object sender, EventArgs e)
        {
            int lineCount = (int)nud_LineCount.Value;
            double fieldSize = 0;

            if (double.TryParse(tb_FieldSize.Text, out fieldSize))
            {
                ReadScanFieldExcel(lineCount);
            }
        }

        private void btn_CorrectionFilePathOpen_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                tb_CorrectionFilePath.Text = ofd.FileName;
                SetSettingData((object)tb_CorrectionFilePath);
            }
        }
    }
}