using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[Serializable]
public class ToolNewQuad
{
  [HideInInspector]
  public Vector3 cursorPos;

  [HideInInspector]
  public int indexQuad = 0;
  [HideInInspector]
  public int[] quad = new int[4];

  // [HideInInspector]
  // public Vector2[] uvs = new Vector2[4];

  public void Reset()
  {
    indexQuad = 0;

    quad = new int[4];
  }

  public void Frame(Input input, Pixelgon pixelgon)
  {
    cursorPos = input.twistCursor; // can do more ^-^

    List<Vector3> vectors = pixelgon.vectors;

    if (vectors.Count < 3)
    {
      Debug.Log("Not enough vectors, to form a Quad");
      return;
    }

    // vertice snapping
    int closestVector = 0;
    for (int i = 0; i < vectors.Count; i++)
    {
      if ((vectors[i] - cursorPos).sqrMagnitude < (vectors[closestVector] - cursorPos).sqrMagnitude)
      {
        closestVector = i;
      }
    }

    cursorPos = vectors[closestVector];

    switch (indexQuad)
    {
      case (0):
        if (input.mainCon.trigger.down)
        {
          for (int i = 0; i < quad.Length; i++)
          {
            quad[i] = closestVector;
          }

          indexQuad++;
        }
        break;
      case (1):
        quad[indexQuad] = closestVector;

        if (input.mainCon.trigger.down)
        {
          indexQuad++;
        }
        break;
      case (2):
        quad[indexQuad] = closestVector;

        if (input.mainCon.trigger.down)
        {
          indexQuad++;
        }
        break;
      case (3):
        quad[indexQuad] = closestVector;

        if (input.mainCon.trigger.down)
        {
          // int furthest = 0;
          // for (int i = 1; i < quad.Length; i++)
          // {
          //   if ((vectors[quad[i]] - planar.position).magnitude >
          //     (vectors[quad[furthest]] - planar.position).magnitude)
          //   {
          //     furthest = i;
          //   }
          // }

          // float scale = planar.InverseTransformPoint(vectors[quad[furthest]]).magnitude;

          // for (int i = 0; i < quad.Length; i++)
          // {
          //   uvs[i] = ((Vector2)planar.InverseTransformPoint(
          //     vectors[quad[i]]) / (scale * 2)) + new Vector2(0.5f, 0.5f
          //   );
          // }

          // only tris!
          // that makes everything so much easier
          // the abstraction then follows the model
          // vectors = vertices
          // quads = tri pairs
          // pixels = uvs

          for (int i = 0; i < quad.Length; i++)
          {
            pixelgon.quads.Add(quad[i]);
          }

          indexQuad = 0;
        }
        break;
    }
  }
}