/*

    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

using System;

using System.Drawing;

namespace Diagram {

    public static class Geometry {

        public static readonly float precision = 1e-5f;

        public static readonly float[][] splineMatrix = new float[][] {

            new float[] {  2f, -2f,  1f,  1f },

            new float[] { -3f,  3f, -2f, -1f },

            new float[] {  0f,  0f,  1f,  0f },

            new float[] {  1f,  0f,  0f,  0f } };

        // Compare to points place at line base0-base1

        public static int comparePointsAtLine(PointF a0, PointF a1, PointF base0, PointF base1) {

            if (base0.X < base1.X && a0.X < a1.X) return -1;

            if (base0.X < base1.X && a1.X < a0.X) return  1;

            if (base1.X < base0.X && a0.X < a1.X) return  1;

            if (base1.X < base0.X && a1.X < a0.X) return -1;

            if (base0.Y < base1.Y && a0.Y < a1.Y) return -1;

            if (base0.Y < base1.Y && a1.Y < a0.Y) return  1;

            if (base1.Y < base0.Y && a0.Y < a1.Y) return  1;

            if (base1.Y < base0.Y && a1.Y < a0.Y) return -1;

            return 0;

        }

        public static bool findIntersection(PointF a0, PointF a1, PointF b0, PointF b1, out PointF c) {

            c = new PointF(0f, 0f);

            PointF da = new PointF(a1.X - a0.X, a1.Y - a0.Y);

            PointF db = new PointF(b1.X - b0.X, b1.Y - b0.Y);

            float divider = da.X*db.Y - db.X*da.Y;

            if (Math.Abs(divider) < precision) return false;

            float numeratorX = da.X*(b1.Y*b0.X - b0.Y*b1.X)

                             - db.X*(a1.Y*a0.X - a0.Y*a1.X);

            float numeratorY = db.Y*(a1.X*a0.Y - a0.X*a1.Y)

                             - da.Y*(b1.X*b0.Y - b0.X*b1.Y);

            PointF p = new PointF(numeratorX/divider, numeratorY/divider);

            if ( comparePointsAtLine(p, a0, a0, a1) < 0

              || comparePointsAtLine(p, a1, a0, a1) > 0

              || comparePointsAtLine(p, b0, b0, b1) < 0

              || comparePointsAtLine(p, b1, b0, b1) > 0 )

                return false;

            c = p;

            return true;

        }

        public static float lineLength(PointF p0, PointF p1) {

            return (float)Math.Sqrt(

                (p1.X-p0.X)*(p1.X-p0.X)

              + (p1.Y-p0.Y)*(p1.Y-p0.Y) );

        }

        public static PointF pointAtLine(PointF p0, PointF p1, int index = 0, int count = 1, float padding = 0f) {

            float l = lineLength(p0, p1);

            float px = l > precision ? (p1.X - p0.X)*padding/l : 0f;

            float py = l > precision ? (p1.Y - p0.Y)*padding/l : 0f;

            return new PointF(

                (index+1)*(p1.X - p0.X - 2*px)/(count + 1) + p0.X + px,

                (index+1)*(p1.Y - p0.Y - 2*py)/(count + 1) + p0.Y + py);

        }

        public static PointF splineTangent(float s, PointF p0, PointF p1, PointF t0, PointF t1) {

            float h1 = 3f*splineMatrix[0][0]*s*s + 2f*splineMatrix[1][0]*s + splineMatrix[2][0];

            float h2 = 3f*splineMatrix[0][1]*s*s + 2f*splineMatrix[1][1]*s + splineMatrix[2][1];

            float h3 = 3f*splineMatrix[0][2]*s*s + 2f*splineMatrix[1][2]*s + splineMatrix[2][2];

            float h4 = 3f*splineMatrix[0][3]*s*s + 2f*splineMatrix[1][3]*s + splineMatrix[2][3];

            return new PointF(

                p0.X*h1 + p1.X*h2 + t0.X*h3 + t1.X*h4,

                p0.Y*h1 + p1.Y*h2 + t0.Y*h3 + t1.Y*h4);

        }

        public static PointF splinePoint(float s, PointF p0, PointF p1, PointF t0, PointF t1) {

            float h1 = splineMatrix[0][0]*s*s*s + splineMatrix[1][0]*s*s + splineMatrix[2][0]*s + splineMatrix[3][0];

            float h2 = splineMatrix[0][1]*s*s*s + splineMatrix[1][1]*s*s + splineMatrix[2][1]*s + splineMatrix[3][1];

            float h3 = splineMatrix[0][2]*s*s*s + splineMatrix[1][2]*s*s + splineMatrix[2][2]*s + splineMatrix[3][2];

            float h4 = splineMatrix[0][3]*s*s*s + splineMatrix[1][3]*s*s + splineMatrix[2][3]*s + splineMatrix[3][3];

            return new PointF(

                p0.X*h1 + p1.X*h2 + t0.X*h3 + t1.X*h4,

                p0.Y*h1 + p1.Y*h2 + t0.Y*h3 + t1.Y*h4 );

        }

    }

}