using Aurora.Api.Devices;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace VisionCommon {
    public class AlignDelta : ICloneable {
        private const string STRING_FORMAT = "dX : {0} [mm]\ndY : {1} [mm]\ndT : {2}";
        private const string STRING_FORMAT_UM = "dX : {0} [um]\ndY : {1} [um]\ndT : {2}";
        private const string STRING_SPECIFIER = "F3";

        public DoublePoint Translation;
        private Angle mAngle;

        public double X {
            get { return Translation.X; }
            set { Translation.X = value; }
        }

        public double Y {
            get { return Translation.Y; }
            set { Translation.Y = value; }
        }

        public Angle T {
            get { return mAngle; }
            set { mAngle = value; }
        }

        public AlignDelta() {
            this.Translation = new StaticPoint();
            this.mAngle = Angle.CreateWithDegree(0);
        }

        public AlignDelta(DoublePoint point, Angle angle) {
            this.Translation = point.Clone();
            this.mAngle = angle.Clone() as Angle;
        }

        public AlignDelta(AlignDelta alignDelta) : this(alignDelta.Translation, alignDelta.T) {
        }

        public override bool Equals(object obj) {
            var alignDelta = obj as AlignDelta;
            if (alignDelta == null)
                return false;
            return MathUtil.Equals(this.X, alignDelta.X)
                && MathUtil.Equals(this.Y, alignDelta.Y)
                && this.T.Equals(alignDelta.T);
        }

        public static AlignDelta operator +(AlignDelta ad1, AlignDelta ad2) {
            return new AlignDelta(
                ad1.Translation + ad2.Translation,
                ad1.T + ad2.T);
        }

        public static AlignDelta operator -(AlignDelta ad1, AlignDelta ad2) {
            return new AlignDelta(
                ad1.Translation - ad2.Translation,
                ad1.T - ad2.T);
        }

        public static AlignDelta operator -(AlignDelta alignDelta) {
            return new AlignDelta(-alignDelta.Translation, -alignDelta.T);
        }

        public override string ToString() {
            return String.Format(STRING_FORMAT, ToStringX(), ToStringY(), ToStringT());
        }

        public string ToStringX() {
            return X.ToString(STRING_SPECIFIER);
        }

        public string ToStringY() {
            return Y.ToString(STRING_SPECIFIER);
        }

        public string ToStringT() {
            return T.ToStringOnlyDeg();
        }

        public string ToStringUm() {
            return String.Format(
                STRING_FORMAT_UM,
                $"{MathUtil.ConvertUnitMilliToMicro(Translation.X).ToString("F1")}",
                $"{MathUtil.ConvertUnitMilliToMicro(Translation.Y).ToString("F1")}",
                ToStringT());
        }

        public object Clone() {
            return new AlignDelta(
                Translation.Clone(),
                mAngle.Clone() as Angle);
        }

        public override int GetHashCode() => 0;

        public bool IsValid() {
            return !double.IsNaN(X) && !double.IsNaN(Y);
        }

        public Position ToPosition() {
            return new Position() {
                X = this.X,
                Y = this.Y,
                T = this.T.Degree,
                Z = 0
            };
        }
    }
}