using StgSharp.Control;
using StgSharp.Linear;
using StgSharp.Math;
using System;
using System.Collections.Generic;
using System.Text;

namespace StgSharp.Geometries
{
    internal class Parallelogram : IPlainGeometry
    {
        internal Point _basePoint;
        internal Point _center;
        internal Point _vertex1;
        internal Point _vertex2;
        internal RenderMode _renderMode;
        internal readonly uint bornTick;

        public override sealed Point RefOrigin => _basePoint;
        public override sealed Point RefPoint => _center;

        public override sealed Point RefVec01 => _vertex1;

        public override sealed Point RefVec02 => _vertex2;

        public override RenderMode renderMode => _renderMode;

        public Parallelogram(uint bornTime) : base(bornTime)
        {
            bornTick = bornTime;
        }

        public Parallelogram(Counter<uint> tickCounter) : base(tickCounter)
        {
            bornTick = tickCounter._value;
        }

        internal override sealed void OnRender(uint tick)
        {
            tick -= bornTick;
            CalcVec01(tick);
            switch (renderMode)
            {
                case RenderMode.BasePoint:
                    CalcVec02(_basePoint._position, tick);
                    CalcVec03(_basePoint._position, tick);
                    break;
                case RenderMode.RefPoint:
                    CalcVec02(_center._position, tick);
                    CalcVec03(_center._position, tick);
                    break;
                default:
                    break;
            }
        }

        public override sealed float SetArrayX()
        {
            throw new NotImplementedException();
        }

        public override sealed float SetArrayY()
        {
            throw new NotImplementedException();
        }

        //计算参考中心点的位移
        internal override void CalcVec01(uint tick)
        {
            _center._position = _basePoint._position + MovCenter(tick);
        }

        //计算第一个顶点的位移，存在相对中心位移和相对参考原点位移两种模式
        internal override void CalcVec02(vec3d vec, uint tick)
        {
            _vertex1._position = vec + UpdateCTC1(tick);
        }

        //计算第二个顶点的位移，存在相对中心位移和相对参考原点位移两种模式
        internal override void CalcVec03(vec3d vec, uint tick)
        {
            _vertex2._position = vec + UpdateCTC2(tick);
        }


        internal sealed override void CalcVec04(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec05(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec06(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec07(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec08(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec09(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec10(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec11(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec12(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec13(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec14(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec15(vec3d vec, uint tick) => throw new UnusedVertexException();
        internal sealed override void CalcVec16(vec3d vec, uint tick) => throw new UnusedVertexException();

        public virtual vec3d MovCenter(uint tick) => default(vec3d);

        public virtual vec3d UpdateCTC1(uint tick) => default(vec3d);

        public virtual vec3d UpdateCTC2(uint tick) => default(vec3d);

        /// <summary>
        /// 获取平行四边形的全部边
        /// </summary>
        /// <returns></returns>
        public override Line[] GetAllSides()
        {

            Line[] sides = new Line[4]
                {   
                    new Line(GameTimeLine.tickCounter),
                    new Line(GameTimeLine.tickCounter),
                    new Line(GameTimeLine.tickCounter),
                    new Line(GameTimeLine.tickCounter),
                };


            sides[0]._basePoint = this._vertex1;
            sides[0]._beginPoint = this._vertex1;
            sides[0]._endPoint = this._vertex2;

            sides[1]._basePoint = this._vertex2;
            sides[1]._beginPoint = this._vertex2;
            sides[1]._endPoint = new Point() { _position = GetVertex3(GameTimeLine.tickCounter)};
            sides[1].movEnd += this.GetVertex3;

            sides[2]._basePoint = sides[1]._endPoint;
            sides[2]._beginPoint = sides[2]._basePoint;
            sides[2]._endPoint = new Point() { _position = this.GetVertex4(GameTimeLine.tickCounter) };
            sides[2].movEnd+= this.GetVertex4;

            sides[3]._beginPoint = sides[2]._endPoint;
            sides[3]._endPoint = this._vertex1;

            return sides;
        }

        public override Plain GetPlain()
        {
            return new Plain(this._center, this._vertex1,this._vertex2);
        }
        
        protected vec3d GetVertex3(Counter<uint> tick)
        {
            return 2 * this._center._position - this._vertex1._position;
        }

        protected vec3d GetVertex4(Counter<uint> tick)
        {
            return 2 * this._center._position - this._vertex2._position;
        }

    }
}