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

public enum Scene { AssetSpace, Pixelgon, StretchSilo }
public class Monolith : MonoBehaviour
{
  public Input input; // INPUT
  public Pixelgon pixelgon; // DATA
  public AssetSpace assetSpace;

  [Button] public void Save() { assetSpace.Save(pixelgon); }
  [Button] public void Load() { pixelgon = assetSpace.Load(); }

  // Tools/Systems
  // public ToolNewQuad toolNewQuad;
  public ToolNewVector toolNewVector;
  public ToolEditVector toolEditVector;
  public ToolEraser toolEraser;

  // stretch-silo
  public StretchSilo stretchSilo;

  public Render render; // VIEW

  void Start()
  {
    assetSpace.Init(render.polyVector);
  }

  public Scene scene;
  int toolIndex = 0;
  void Update()
  {
    input.Frame();

    switch (scene)
    {
      case Scene.AssetSpace:
        assetSpace.Frame(input, render);
        break;

      case Scene.Pixelgon:
        // toolNewQuad.Frame(input, pixelgon);
        // render.ToolNewQuad(toolNewQuad);
        if (input.offCon.two.down)
        {
          toolNewVector.Reset();
          toolEditVector.Reset();
          toolEraser.Reset();
          if (toolIndex < 2)
          {
            toolIndex++;
          }
          else
          {
            toolIndex = 0;
          }
        }

        switch (toolIndex)
        {
          case 0:
            toolNewVector.Frame(input, pixelgon);
            render.ToolNewVector(toolNewVector);
            break;
          case 1:
            toolEditVector.Frame(input, pixelgon);
            render.ToolEditVector(toolEditVector);
            break;
          case 2:
            toolEraser.Frame(input, pixelgon);
            render.ToolEraser(toolEraser);
            break;
        }

        render.Pixelgon(pixelgon);
        break;

      case Scene.StretchSilo:
        render.StretchSilo(stretchSilo, assetSpace);
        break;
    }

    render.Frame(input);
  }
}

public static class StaticMethods
{
  public static List<Vector3> DeleteLoose(List<Vector3> vectors)
  {
    int length = 0;
    for (int i = vectors.Count - 1; i >= 0; i--)
    {
      if (vectors[i] != Vector3.zero)
      {
        length++;
      }
      else
      {
        if (length == 1)
        {
          vectors.RemoveAt(i + 1);
        }

        length = 0;
      }
    }

    return vectors;
  }

  public static bool Inside(float from, float to, float x)
  {
    if (from < to)
    {
      return x > from && x < to;
    }
    else
    {
      return x > to && x < from;
    }
  }

  static Vector3[] snappingDir = new Vector3[] { Vector3.right, Vector3.up, Vector3.forward };
  public static Vector3 DirSnap(Vector3 a, Vector3 c)
  {
    for (int i = 0; i < snappingDir.Length; i++)
    {
      for (int j = 0; j < 2; j++)
      {
        Vector3 snapDir = snappingDir[i];
        if (j == 1)
        {
          snapDir = snappingDir[i] * -1f; // right -> left etc.
        }

        Vector3 dir = (c - a).normalized;
        if (Vector3.Angle(snapDir, dir) < 8f) // dir snapping margin
        {
          return a + snapDir * Vector3.Distance(a, c);
        }
      }
    }

    return c;
  }

  public static Vector3 EdgeSnap(Vector3 a, Vector3 b, Vector3 c)
  {
    Quaternion perspective = Quaternion.LookRotation(b - a);
    Vector3 pA = Quaternion.Inverse(perspective) * a;
    Vector3 pB = Quaternion.Inverse(perspective) * b;
    Vector3 pC = Quaternion.Inverse(perspective) * c;

    // XY
    float dist = Vector2.Distance(pC, pA); // pA & pB interchangeable

    // Z
    if (pC.z < pA.z || pC.z > pB.z) // outside
    {
      dist += Mathf.Min(Mathf.Abs(pC.z - pA.z), Mathf.Abs(pC.z - pB.z));
    }

    // snapping margin, where is this variable?
    // idk becuase this snapping system will be reused in tools and quads
    // scalable 0-1 * design (0 == no snapping) set parameter in ORIEL UI

    // min distance to handle 2+ conflicting snaps
    if (dist < 0.02f)
    {
      pC.x = pA.x;
      pC.y = pA.y;

      pC.z = Mathf.Clamp(pC.z, pA.z, pB.z);

      return perspective * pC;
    }

    return c;
  }
}