using System.Collections.Generic;
using UnityEngine;

public class Max2D {
    private static Material lineMaterial;
    private static Material lineEndMaterial;
    private static Material defaultMaterial;

    private static float lineWidth = 0.2f;
    private static bool smooth = false;
    private static bool setBorder = false;
    private static Color setColor = Color.white;

    static public void SetBorder(bool border)
    {
        setBorder = border;
    }

    static public void SetSmooth(bool _smooth)
    {
        smooth = _smooth;
    }

    public static void SetLineWidth (float size)
    {
        lineWidth = Mathf.Max(.01f, size / 5f);
    }

    static public void SetColor(Color color)
    {
        Check ();
        lineMaterial.SetColor ("_Emission", color);
        lineEndMaterial.SetColor ("_Emission", color);
        setColor = color;
    }

    private static void Check()
    {
        if (lineMaterial == null || lineEndMaterial == null) {
            lineMaterial = new Material (Shader.Find ("Legacy Shaders/Transparent/VertexLit"));
            lineMaterial.mainTexture = Resources.Load ("Textures/LineTexture") as Texture;
            lineEndMaterial = new Material (Shader.Find ("Legacy Shaders/Transparent/VertexLit"));
            lineEndMaterial.mainTexture = Resources.Load ("Textures/LineEndTexture") as Texture;
            lineEndMaterial.mainTextureScale = new Vector2 (0.52f, 1f);
            lineEndMaterial.mainTextureOffset = new Vector2 (-0.58f, 0f);
            lineMaterial.SetInt("_ZWrite", 0);
            lineEndMaterial.SetInt("_ZWrite", 0);
        }
        if (defaultMaterial == null) {
            Shader shader = Shader.Find("Hidden/Internal-Colored");
            defaultMaterial = new Material(shader);
            defaultMaterial.hideFlags = HideFlags.HideAndDontSave;
            defaultMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
            defaultMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
            defaultMaterial.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
            defaultMaterial.SetInt("_ZWrite", 0);
        }
    }

    static public void iDrawMesh(Mesh mesh, Transform transform, Vector2f offset, float z)
    {
        if (mesh == null)
            return;

        List<Vector2> list = new List<Vector2>();
        for (int i = 0; i <  mesh.triangles.GetLength (0); i++ ) {
            list.Add (transform.TransformPoint(mesh.vertices [mesh.triangles [i]]));
            if (list.Count > 2) {
                DrawTriangle (new Vector2f (list [0]), new Vector2f (list [1]), new Vector2f (list [2]), offset, z);
                list.Clear ();
            }
        }
    }

    static public void iDrawImage(Material material, Vector2f pos, Vector2f size, float z = 0f)
    {
        GL.PushMatrix ();
        material.SetPass (0);

        GL.Begin (GL.QUADS);
        GL.TexCoord2 (0, 0);
        GL.Vertex3 (pos.GetX() - size.GetX(), pos.GetY() - size.GetY(), z);
        GL.TexCoord2 (0, 1);
        GL.Vertex3 (pos.GetX() - size.GetX(), pos.GetY() + size.GetY(), z);
        GL.TexCoord2 (1, 1);
        GL.Vertex3 (pos.GetX() + size.GetX(), pos.GetY() + size.GetY(), z);
        GL.TexCoord2 (1, 0);
        GL.Vertex3 (pos.GetX() + size.GetX(), pos.GetY() - size.GetY(), z);
        GL.End ();

        GL.PopMatrix ();
    }

    static public void iDrawLine(float x0, float y0, float x1, float y1, float z = 0f)
    {
        Check ();

        if (smooth == true)
            DrawSmoothLine (new Pair2f (new Vector2f (x0, y0), new Vector2f (x1, y1)), z);
        else {
            GL.PushMatrix();
            defaultMaterial.SetPass(0);
            GL.Begin(GL.LINES);
            GL.Color(setColor);
            GL.Vertex3(x0, y0, z);
            GL.Vertex3(x1, y1, z);
            GL.End();
            GL.PopMatrix();
        }
    }

    static public void DrawTriangle(Vector2f p0, Vector2f p1, Vector2f p2, Vector2f offset, float z = 0f)
    {
        iDrawTriangle (p0.GetX (), p0.GetY (), p1.GetX (), p1.GetY (), p2.GetX (), p2.GetY (), offset, z);
    }

    static public void iDrawTriangle(float x0, float y0, float x1, float y1, float x2, float y2, Vector2f offset, float z = 0f)
    {
        GL.PushMatrix();
        defaultMaterial.SetPass(0);
        GL.Begin(GL.TRIANGLES);
        GL.Color(setColor);
        GL.Vertex3(x0 + offset.GetX(), y0 + offset.GetY(), z);
        GL.Vertex3(x1 + offset.GetX(), y1 + offset.GetY(), z);
        GL.Vertex3(x2 + offset.GetX(), y2 + offset.GetY(), z);
        GL.End();
        GL.PopMatrix();
    }

    static public void Vertex3(Vector2f p, float z)
    {
        GL.Vertex3(p.GetX(), p.GetY(), z);
    }

    static public void iDrawRect(float x, float y, float w, float h, float z = 0f)
    {
        DrawLine(new Vector2f(x, y),            new Vector2f(x + w, y), z);
        DrawLine(new Vector2f(x + w, y),        new Vector2f( x + w, y + h), z);
        DrawLine(new Vector2f(x + w, y + h),    new Vector2f( x, y + h), z);
        DrawLine(new Vector2f(x, y + h),        new Vector2f(x, y), z);
    }

    static public void DrawSquare(Vector2f p, float size, float z = 0f)
    {
        iDrawRect (p.GetX() - size / 2f, p.GetY() - size / 2f, size, size, z);
    }

    static public void DrawSquareFilled(Vector2f p, float size, float z = 0f)
    {
        Vector2f p0 = new Vector2f (p.GetX () - size, p.GetY () - size);
        Vector2f p1 = new Vector2f (p.GetX () + size, p.GetY () - size);
        Vector2f p2 = new Vector2f (p.GetX () + size, p.GetY () + size);
        Vector2f p3 = new Vector2f (p.GetX () - size, p.GetY () + size);

        DrawTriangle (p0, p1, p2, new Vector2f(0, 0), z);
        DrawTriangle (p2, p3, p0, new Vector2f(0, 0), z);
    }

    static public void DrawLine(Vector2f p0, Vector2f p1, float z = 0f)
    {
        if (setBorder == true) {
            Color tmcColor = setColor;
            float tmpWidth = lineWidth;
            SetColor(Color.black);
            SetLineWidth (1);
            iDrawLine (p0.GetX (), p0.GetY (), p1.GetX (), p1.GetY (), z);
            SetColor(tmcColor);
            SetLineWidth (0.5f);
            iDrawLine (p0.GetX (), p0.GetY (), p1.GetX (), p1.GetY (), z);
            SetLineWidth (tmpWidth);
        } else {
            iDrawLine (p0.GetX (), p0.GetY (), p1.GetX (), p1.GetY (), z);
        }
    }

    static public void DrawSlice(List< Vector2f> slice, float z = 0f)
    {
        foreach (Pair2f p in Pair2f.GetList(slice, false))
            DrawLine (p.A, p.B, z);
    }

    static public void DrawPolygonList(List<Polygon> polyList, float z = 0f)
    {
        foreach (Polygon p in polyList)
            DrawPolygon (p, z);
    }

    static public void DrawStrippedLine(List<Vector2f> pointsList, float minVertsDistance, float z, bool full = false, Vector2f offset = null)
    {
        if (offset == null)
            offset = new Vector2f (0, 0);

        Vector2f vA = null, vB = null;
        foreach (Pair2f id in Pair2f.GetList(pointsList, full)) {
            vA = new Vector2f (id.A.Get () + offset.Get());
            vB = new Vector2f (id.B.Get () + offset.Get());

            vA.Push (Vector2f.Atan2 (id.A, id.B), -minVertsDistance / 4);
            vB.Push (Vector2f.Atan2 (id.A, id.B), minVertsDistance / 4);

            Max2D.DrawLine (vA, vB, z);
        }
    }

    static public void DrawSmoothLine(Pair2f pair, float z)
    {
        GL.PushMatrix();
        GL.Begin(GL.QUADS);
        lineMaterial.SetPass(0);

        DrawSmoothLine_Algorithm (pair, z);

        GL.End();
        GL.PopMatrix();
    }

    static public void DrawPolygon(Polygon poly, float z = 0f)
    {
        Check ();

        if (smooth) {
            GL.PushMatrix ();

            lineMaterial.SetPass(0);

            GL.Begin(GL.QUADS);
            foreach (Pair2f p in Pair2f.GetList(poly.pointsList))
                DrawSmoothLine_Algorithm (p, z);

            GL.End();

            GL.PopMatrix();
        } else {
            GL.PushMatrix();

            defaultMaterial.SetPass(0);

            GL.Begin(GL.LINES);
            GL.Color(setColor);

            foreach (Pair2f p in Pair2f.GetList(poly.pointsList)) {
                GL.Vertex3(p.A.GetX(), p.A.GetY(), z);
                GL.Vertex3(p.B.GetX(), p.B.GetY(), z);
            }

            GL.End ();
            GL.PopMatrix();
        }

        foreach (Polygon p in poly.holesList)
            DrawPolygon (p, z);

    }

    private static void DrawSmoothLine_Algorithm(Pair2f pair, float z)
    {
        float size = lineWidth;
        float rot = Vector2f.Atan2 (pair.A, pair.B);

        float pi2 = Mathf.PI / 2;
        float pi = Mathf.PI;

        Vector2f A1 = new Vector2f (pair.A);
        Vector2f A2 = new Vector2f (pair.A);
        Vector2f A3 = new Vector2f (pair.A);
        Vector2f A4 = new Vector2f (pair.A);

        Vector2f B1 = new Vector2f (pair.B);
        Vector2f B2 = new Vector2f (pair.B);
        Vector2f B3 = new Vector2f (pair.B);
        Vector2f B4 = new Vector2f (pair.B);

        A1.Push (rot + pi2, size);
        A2.Push (rot - pi2, size);

        A3.Push (rot + pi2, size);
        A4.Push (rot - pi2, size);
        A3.Push (rot + pi, -size);
        A4.Push (rot + pi, -size);

        B1.Push (rot + pi2, size);
        B2.Push (rot - pi2, size);

        B3.Push (rot + pi2, size);
        B4.Push (rot - pi2, size);
        B3.Push (rot + pi, size);
        B4.Push (rot + pi , size);



        GL.TexCoord2(0, 0);
        GL.Vertex3(B1.GetX(), B1.GetY(), z);
        GL.TexCoord2(1, 0);
        GL.Vertex3(A1.GetX(), A1.GetY(), z);
        GL.TexCoord2(1, 1);
        GL.Vertex3(A2.GetX(), A2.GetY(), z);
        GL.TexCoord2(0, 1);
        GL.Vertex3(B2.GetX(), B2.GetY(), z);



        /*lineEndMaterial.SetPass(0);

        GL.Begin(GL.QUADS);

        GL.TexCoord2(0, 0);
        GL.Vertex3(A3.GetX(), A3.GetY(), z);
        GL.TexCoord2(0, 1);
        GL.Vertex3(A4.GetX(), A4.GetY(), z);
        GL.TexCoord2(1, 1);
        GL.Vertex3(A2.GetX(), A2.GetY(), z);
        GL.TexCoord2(1, 0);
        GL.Vertex3(A1.GetX(), A1.GetY(), z);
        GL.TexCoord2(0, 0);
        GL.Vertex3(B4.GetX(), B4.GetY(), z);
        GL.TexCoord2(0, 1);
        GL.Vertex3(B3.GetX(), B3.GetY(), z);
        GL.TexCoord2(1, 1);
        GL.Vertex3(B1.GetX(), B1.GetY(), z);
        GL.TexCoord2(1, 0);
        GL.Vertex3(B2.GetX(), B2.GetY(), z);

        GL.End();*/
    }

}