using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using TSA_V.Common;
using TSA_V.DeviceLibrary;

namespace UserFromControl
{
    public partial class ProjectorControl : UserControl
    {
        public static Dictionary<int,int> LastStepIndexMap=null;
        public   int ConType = 0;//坐标类型，0=投影，1=mm/离线编程
        public    int MaxX = 1920;
        public    int MaxY = 1280;

        public   double X_ChangeValue = 1;
        public   double Y_ChangeValue = 1;
        public delegate bool  ShowPointDelegate(ProjectorPInfo p);
        public event ShowPointDelegate ShowPointEvent;
        public ProjectorControl()
        {
            if (ImageManager.IsInit == false)
            {
                ImageManager.Init();
            }
            InitializeComponent();
            if (LastStepIndexMap == null)
            {
                LastStepIndexMap = new Dictionary<int, int>();
                LastStepIndexMap.Add(0, 1);
                LastStepIndexMap.Add(1, 0);
            }
            cmbStep.SelectedIndex = LastStepIndexMap[ConType];
            if (cmbType.SelectedIndex < 0)
            {
                cmbType.SelectedIndex = 0;
            }
            cmbpolarities.SelectedIndex = 0;
            PointSizeX = Setting_NInit.Device_DefaultPointSize;
            PointSizeY = Setting_NInit.Device_DefaultPointSize;
            PointType = Setting_NInit.Device_DefaultPointType;
            PolaritiesType = 0;
            numSizeX.Maximum = MaxX / 2;
            numSizeY.Maximum=MaxY/ 2;
            btnUp.BackgroundImage = ImageManager.imgUp;
            btnDown.BackgroundImage = ImageManager.imgDown;
            btnLeft.BackgroundImage = ImageManager.imgLeft;
            btnRight.BackgroundImage = ImageManager.imgRight;

            pictureBox1.Image = ImageManager.imgType1;
            pictureBox2.Image = ImageManager.imgType2;
            pictureBox3.Image = ImageManager.imgType3;
            pictureBox4.Image = ImageManager.imgType4;
            pictureBox5.Image = ImageManager.imgType5;
            pictureBox6.Image = ImageManager.imgType6;
        }
        public   void loadTypeList(string[] list, string[] dirlist,Dictionary<string,string> controlTextMap)
        {
            int oldT = cmbType.SelectedIndex;
            int oldPt=cmbpolarities.SelectedIndex; 
            typeList = new List<string>();
            this.cmbType.Items.Clear(); 
            typeList.AddRange(list);
            foreach (string str in typeList)
            {
                cmbType.Items.Add(str);
            }
            cmbpolarities.Items.Clear();
            foreach(string str in dirlist)
            {
                cmbpolarities.Items.Add(str);
            }
            cmbType.SelectedIndex = oldT;
            cmbpolarities.SelectedIndex = oldPt;

            group.Text = controlTextMap["group_Text"];
            lblLineWidth.Text = controlTextMap["lblLineWidth_Text"];
            lblName.Text = controlTextMap["lblName_Text"];
            lblSizeLength.Text = controlTextMap["lblSizeLength_Text"];
            lblSizeWidth.Text = controlTextMap["lblSizeWidth_Text"];
            lblStepValue.Text = controlTextMap["lblStepValue_Text"];
            lbltype.Text = controlTextMap["lbltype_Text"];
            lblx.Text = controlTextMap["lblx_Text"];
            lbly.Text = controlTextMap["lbly_Text"];

            btnDown.Text = controlTextMap["btnDown_Text"];
            btnUp.Text = controlTextMap["btnUp_Text"];
            btnShowPoint.Text = controlTextMap["btnShowPoint_Text"];
            btnLeft.Text = controlTextMap["btnLeft_Text"];
            btnRight.Text = controlTextMap["btnRight_Text"];
            lblPolarities.Text = controlTextMap["lblPolarities_Text"];


            btnDown.Text = "";
            btnUp.Text = "";
            btnLeft.Text = "";
            btnRight.Text = "";
            //
        }
        public string GroupName
        {
            get { return group.Text; }
            set
            {
                group.Text = value;
            }
        }

        public int ShowColor = -1;

        private void btnShowPoint_Click(object sender, EventArgs e)
        {
            ShowCurrPoint();
        }
        public ProjectorPInfo GetPInfo()
        {
            double px = (double)(numX.Value);
            double py = (double)(numY.Value);
            int pointType = cmbType.SelectedIndex + 1;
            int sizeX = FormUtil.GetIntValue(numSizeX);
            int sizeY = FormUtil.GetIntValue(numSizeY);
            int penWidth = (int)numPenWidth.Value;
            string name = FormUtil.getValue(txtname);
            int ptype = cmbpolarities.SelectedIndex;
            int angle = (int)numAngle.Value;
            angle = ProjectorPInfo.getAngleByType(ptype, angle);
            ////如果亮度和大小超过范围，直接用默认值
            //if (sizeX < 1 || sizeX > 255)
            //{
            //    sizeX = DefaultPSize;
            //    numSizeX.Text = sizeX.ToString();
            //}
            //if (sizeY < 1 || sizeY > 255)
            //{
            //    sizeY = DefaultPSize;
            //    numSizeY.Text = sizeY.ToString();
            //}
            ProjectorPInfo p = new ProjectorPInfo(px, py, pointType,ptype, angle, sizeX, sizeY, penWidth,name, ShowColor);
            return p;
        }
        public void ShowCurrPoint()
        {
            this.Cursor = Cursors.WaitCursor;  
            ShowPointEvent?.Invoke(GetPInfo());
            this.Cursor = Cursors.Default;
        }
        private void btnUp_Click(object sender, EventArgs e)
        {

            double stepValue = (double)(GetStepValue() * Y_ChangeValue);
            double targetValue = (double)(numY.Value) - stepValue;
            if (targetValue >=(double) numY.Minimum )
            {
                numY.Value =(decimal) targetValue ;
                ShowCurrPoint();
            }
            else
            { 
                numY.Text = 1.ToString();
                ShowCurrPoint();
            }
        }

        private void btnLeft_Click(object sender, EventArgs e)
        {
            double stepValue = (double)(GetStepValue() * X_ChangeValue);
            double targetValue = (double)(numX.Value) - stepValue;
            if (targetValue >=(double) numX.Minimum  )
            {
                numX.Value = (decimal)targetValue;
                ShowCurrPoint();
            }
            else
            { 
                numX.Text = 1.ToString();
                ShowCurrPoint();
            }
        }

        private void btnRight_Click(object sender, EventArgs e)
        { 
            double stepValue = (double)(GetStepValue() * X_ChangeValue);
           
            double targetValue =(double)numX.Value+ stepValue;
            if (  targetValue <=(double)numX.Maximum)
            {
                numX.Value = (decimal)targetValue;
                ShowCurrPoint();
            }
            else
            {
                numX.Text = MaxX.ToString();
                ShowCurrPoint();
            }
        }

        private void btnDown_Click(object sender, EventArgs e)
        {
            double stepValue = (double)(GetStepValue() * Y_ChangeValue);
            double targetValue = (double)(numY.Value) + stepValue; 
            if (  targetValue <= (double)numY.Maximum)
            {
                numY.Value  = (decimal)targetValue;
                ShowCurrPoint();
            }
            else
            {
                numY.Text = MaxY.ToString();
                ShowCurrPoint(); 
            }
        }


        private void cmbType_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cmbType.SelectedIndex >= 1 && cmbType.SelectedIndex <= 3)
            {
                numSizeY.Text = numSizeX.Text;
            }
            if (!(cmbType.SelectedIndex + 1).Equals(lastType))
            {
                lastType = cmbType.SelectedIndex + 1; 
                DrawPoint(lastType,lastPolaritiesType, lastAngle); 
                ShowCurrPoint();
                TypeUpdate(cmbType.SelectedIndex);
            }
        }
        private int  lastType=1;
        private int lastPolaritiesType = 0;
        private int lastAngle = 0;
        public double XValue
        {
            set
            {
                numX.Text = (value).ToString();
            }
            get
            {
                return  (double)numX.Value;
            }
        }
         
        public double YValue
        {
            set
            {
                numY.Text = (value).ToString();
            }
            get
            {
                return (double)numY.Value;
            }
        }
        public int PointType
        {
            set
            {
                if ((int)value > cmbType.Items.Count)
                {
                    value = cmbType.Items.Count - 1;
                }
                    if ((int) value >= 1)
                {
                    cmbType.SelectedIndex = ((int)value) - 1;
                }
                else
                {
                    cmbType.SelectedIndex = 0;
                }
            }
            get
            {
                return cmbType.SelectedIndex+1;
            }
        }
        public int PointSizeX
        {
            set
            {
                numSizeX.Text = ((int)value).ToString();
            }
            get
            {
                return FormUtil.GetIntValue(numSizeX);
            }
        }
        public int PointSizeY
        {
            set
            {
                numSizeY.Text = ((int)value).ToString();
            }
            get
            {
                return FormUtil.GetIntValue(numSizeY);
            }
        }
        public int PenWidth
        {
            set
            {
                numPenWidth.Text = ((int)value).ToString();
            }
            get
            {
                return FormUtil.GetIntValue(numPenWidth);
            }
        }
        public string ShowText
        {
            set
            {
                txtname.Text = (value).ToString();
            }
            get
            {
                return FormUtil.getValue(txtname);
            }
        }
        public int PolaritiesType
        {
            set
            {
                if ((int)value >= cmbpolarities.Items.Count)
                {
                    value = cmbpolarities.Items.Count - 1;
                }
                if ((int)value >= 0)
                {
                    cmbpolarities.SelectedIndex = ((int)value)  ;
                }
                else
                {
                    cmbpolarities.SelectedIndex = 0;
                }
            }
            get
            {
                return cmbpolarities.SelectedIndex;
            }
        }

        public int PolarityAngle
        {
            set
            { 
                if ((int)value >= 0)
                {
                    numAngle.Value = value;
                }
                else
                {
                    numAngle.Value = ProjectorPInfo.getAngleByType(PolaritiesType, value);
                }
            }
            get
            {
                return (int) numAngle.Value;
            }
        }

        public void UpdateStatus()
        {
            //numX.Text = GalvanometerManager.GetLastPoint().X.ToString();
            //numY.Text = GalvanometerManager.GetLastPoint().Y.ToString();
        }
        private List<double> vallue = new List<double>() { 1, 2, 5, 10, 20, 50,100 };

        private double GetStepValue()
        {
            int index = cmbStep.SelectedIndex; 
            LastStepIndexMap[ConType]= index;
            if (vallue.Count > index)
            {
                return vallue[index];
            }
            return 10;
        }
        private List<string> typeList = new List<string>();

        private List<PictureBox> pictureBoxes = new List<PictureBox>();
        private List<Image> picDefImages = new List<Image>();
        private List<Image> picSelImages = new List<Image>();
        private void ProjectorControl_Load(object sender, EventArgs e)
        {
            try
            {
                if (cmbType.SelectedIndex < 0)
                {
                    cmbType.SelectedIndex = 0;
                }
                numSizeX.Maximum = MaxX / 2;
                numSizeY.Maximum = MaxY / 2;

                //重新设置步进值
                if (ConType == 1)
                {
                    this.cmbStep.Items.Clear();
                    this.cmbStep.Items.AddRange(new object[] {
            "0.1",
            "0.2",
            "0.5",
            "1",
            "2",
            "5",
            "10",
            "20",
            "50",
            "100"});
                    numX.DecimalPlaces = 3;
                    numY.DecimalPlaces = 3;
                    vallue = new List<double>() { 0.1, 0.2, 0.51, 2, 5, 10, 20, 50, 100 };
                }
                else
                {
                    numX.DecimalPlaces = 0;
                    numY.DecimalPlaces = 0;
                }
                int sindex = LastStepIndexMap[ConType];
                if (cmbStep.Items.Count > sindex)
                { 
                    cmbStep.SelectedIndex = LastStepIndexMap[ConType];
                }
                else
                {
                    cmbStep.SelectedIndex = cmbStep.Items.Count / 2;
                }
                pictureBoxes.Add(pictureBox1);
                pictureBoxes.Add(pictureBox2);
                pictureBoxes.Add(pictureBox3);
                pictureBoxes.Add(pictureBox4);
                pictureBoxes.Add(pictureBox5);
                pictureBoxes.Add(pictureBox6);

                picDefImages.Add(ImageManager.imgType1);
                picDefImages.Add(ImageManager.imgType2);
                picDefImages.Add(ImageManager.imgType3);
                picDefImages.Add(ImageManager.imgType4);
                picDefImages.Add(ImageManager.imgType5);
                picDefImages.Add(ImageManager.imgType6);

                picSelImages.Add(ImageManager.imgType1s);
                picSelImages.Add(ImageManager.imgType2s);
                picSelImages.Add(ImageManager.imgType3s);
                picSelImages.Add(ImageManager.imgType4s);
                picSelImages.Add(ImageManager.imgType5s);
                picSelImages.Add(ImageManager.imgType6s);


                TypeUpdate(cmbType.SelectedIndex);
            }
            catch (Exception ex)
            {
                LogUtil.error("ProjectorControl_Load 出错：" + ex.ToString());
            }
        }
        private void DrawPoint(int type,int polaritiesType  ,int angle, int x=0, int y=0,  int sizeX = 2, int sizeY = 2 ,int lineLength=2  )
        {
            Graphics g = panImg.CreateGraphics();
            if (sizeX < 2)
            {
                sizeX = 2;
            }
            if (sizeY < 2)
            {
                sizeY = 2;
            }
            x = panImg.Width / 2;
            y = panImg.Height / 2;
            sizeX = x > y ? (x / 4) : (y / 4);
            sizeY = sizeX;
            

            g.Clear(panImg.BackColor);

            Pen pen = new Pen(panImg.ForeColor, lineLength);
            int pointWidth = sizeX;//圆形的半径
            if (sizeY > sizeX)
            {
                pointWidth = sizeY;
            }
            System.Drawing.SolidBrush myBrush = new System.Drawing.SolidBrush(panImg.ForeColor);
            //点类型，1 = 点，2 = +，3 =|，4 = -，5 = 方形，6 = 圆圈
            if (type.Equals(2))
            {
                g.DrawLine(pen, new Point(x - sizeX, y), new Point(x + sizeX, y));
                g.DrawLine(pen, new Point(x, y - sizeY), new Point(x, y + sizeY));
            }
            else if (type.Equals(3))
            {
                g.DrawLine(pen, new Point(x, y - sizeY), new Point(x, y + sizeY));
            }
            else if (type.Equals(4))
            {
                g.DrawLine(pen, new Point(x - sizeX, y), new Point(x + sizeX, y));
            }
            else if (type.Equals(5))
            {
                g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if (type.Equals(6))
            {
                g.DrawEllipse(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }else if (type>6)
            { 
                g.DrawEllipse(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else
            {
                g.FillEllipse(myBrush, new Rectangle(x - sizeX / 2, y - sizeY / 2, sizeX, sizeY));//画实心椭圆          
            }
              if (polaritiesType.Equals(0))
            {

            } 
            else if (polaritiesType.Equals(1))
            {
                //sizeX = 12;
                //sizeY = 36;
                int plusSize = sizeX / 2;
                int pX = x;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize)); 
            }
            else if (polaritiesType.Equals(2))
            {
                //sizeX = 12;
                //sizeY = 36;
                int plusSize = sizeX / 2;
                int pX = x;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (polaritiesType.Equals(3))
            {
                //sizeX = 12;
                //sizeY = 36;

                int plusSize = sizeY / 2;
                int pX = x - sizeX / 2 - lineLength - plusSize;
                int pY = y;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (polaritiesType.Equals(4))
            {
                //sizeX = 12;
                //sizeY = 36;

                int plusSize = sizeY / 2;
                int pX = x + sizeX / 2 + lineLength + plusSize;
                int pY = y;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (polaritiesType.Equals(5))
            {
                //sizeX = 12;
                //sizeY = 36;
                int plusSize = sizeX / 2;
                int pX = x - 6;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));

            }
            
            else if (polaritiesType.Equals(6))
            {
                //sizeX = 12;
                //sizeY = 36;
                int plusSize = sizeX / 2;
                int pX = x + 6;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
                 
            }
            else if (polaritiesType.Equals(7))
            {
                //sizeX = 12;
                //sizeY = 36;

                int plusSize = sizeX / 2;
                int pX = x - 6;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (polaritiesType.Equals(8))
            {
                //sizeX = 12;
                //sizeY = 36;

                int plusSize = sizeX / 2;
                int pX = x + 6;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else   if (angle > 0)
            {
                Point drawP = ProjectorPInfo.CalculatePoint(new Point(x, y), pointWidth, angle);

                g.DrawLine(pen, new Point(drawP.X - pointWidth / 2, drawP.Y), new Point(drawP.X + pointWidth / 2, drawP.Y));
                g.DrawLine(pen, new Point(drawP.X, drawP.Y - pointWidth / 2), new Point(drawP.X, drawP.Y + pointWidth / 2));
            }
        }
        private void group_Paint(object sender, PaintEventArgs e)
        {
            return; 
        }

        private void cmbpolarities_SelectedIndexChanged(object sender, EventArgs e)
        {

            if (!(cmbpolarities.SelectedIndex + 1).Equals(lastPolaritiesType))
            {
                lastPolaritiesType = cmbpolarities.SelectedIndex;
                lastAngle =(int) numAngle.Value;
                lastAngle = ProjectorPInfo.getAngleByType(lastPolaritiesType, lastAngle);
                numAngle.Enabled = lastPolaritiesType.Equals(9);
                numAngle.Value = lastAngle;
                DrawPoint(lastType, lastPolaritiesType, lastAngle);
                ShowCurrPoint();
            }
        }

        public void SetPointType(int pointType, int pointSizeX, int pointSizeY, int penWidth, int polaritiesType,int angle)
        {
            this.PointType = pointType;
            this.PointSizeX = pointSizeX;
            this.PointSizeY = pointSizeY;
            this.PenWidth = penWidth;
            this.PolaritiesType = polaritiesType;
            this.PolarityAngle =ProjectorPInfo.getAngleByType(polaritiesType, angle);
        }
        private void TypeUpdate(int index)
        {
            for (int i = 0; i < pictureBoxes.Count; i++)
            {
                if (i.Equals(index))
                {

                    pictureBoxes[i].Image = picSelImages[i];
                }
                else
                {
                    pictureBoxes[i].Image = picDefImages[i];
                }
            } 

        }
        private void pictureBox1_Click(object sender, EventArgs e)
        {
            PointType = 1; 
        }

        private void pictureBox3_Click(object sender, EventArgs e)
        {
            PointType = 3;
        }

        private void pictureBox2_Click(object sender, EventArgs e)
        {
            PointType = 2;
        }

        private void pictureBox4_Click(object sender, EventArgs e)
        {
            PointType = 4;
        }

        private void pictureBox5_Click(object sender, EventArgs e)
        {
            PointType = 5;
        }

        private void pictureBox6_Click(object sender, EventArgs e)
        {
            PointType = 6;
        }

        private void numAngle_ValueChanged(object sender, EventArgs e)
        { 
            lastPolaritiesType = cmbpolarities.SelectedIndex;
            lastAngle = (int)numAngle.Value;
            lastAngle = ProjectorPInfo.getAngleByType(lastPolaritiesType, lastAngle);
            DrawPoint(lastType, lastPolaritiesType, lastAngle);
            ShowCurrPoint();
        }
    }
}