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

public class GeoCap : MonoBehaviour
{
    public float vertexDistance = 0.02f;
    public float outerVertDistance = 0.005f;
    public int minVertsInRing = 8;
    public int minVertsInLastRing = 32;

    MeshFilter meshFilter;

    void Awake()
    {
        meshFilter = GetComponent<MeshFilter>();
    }

    public void OnCapCenterChanged(Vector3 c)
    {
        Vector3 refAxis = new Vector3(0.0f, 1.0f, 0.0f);
        Quaternion q = Quaternion.FromToRotation(refAxis, c);
        transform.rotation = q;
    }

    public void OnCapRadiusChanged(float radius)
    {
        //float s = r / 90.0f;
        //capGeometry.localScale = new Vector3(s, 0.00001f, s);


        float arcLen = Mathf.PI * radius / 180.0f;
        int numRings = ((int)Mathf.Ceil(arcLen / vertexDistance)) + 1;

        // angular separation between consecutive rings
        float deltaLatitude = radius / (numRings - 1);

        //Debug.Log($"Radius:{radius} arcLen={arcLen} numRings={numRings}");

        int[] ringcount = new int[numRings];
        int[] ringoffset = new int[numRings];

        List<Vector3> verts = new List<Vector3>();
        List<int> inds = new List<int>();

        // ring 0 (single vertex at cap center)
        ringcount[0] = 1;
        ringoffset[0] = 0;
        verts.Add(new Vector3(0.0f,1.0f,0.0f));

        Vector3 apex = new Vector3(0.0f, 1.0f, 0.0f);

        for (int ringIndex = 1; ringIndex < numRings; ringIndex++)
        {
            ringoffset[ringIndex] = ringoffset[ringIndex - 1] + ringcount[ringIndex - 1];

            Quaternion rot = Quaternion.Euler(deltaLatitude*ringIndex, 0.0f, 0.0f);
            Vector3 p = rot * apex;
            float circumf = (new Vector2(p.x, p.z).magnitude) * 2 * Mathf.PI;

            int numVerts;
            if (ringIndex == numRings-1)
            {
                numVerts = (int)Mathf.Ceil(circumf / outerVertDistance) + 1;
                if (numVerts < minVertsInLastRing) numVerts = minVertsInLastRing;
            }
            else
            {
                numVerts = (int)Mathf.Ceil(circumf / vertexDistance) + 1;
                if (numVerts < minVertsInRing) numVerts = minVertsInRing;
            }


            ringcount[ringIndex] = numVerts;
            float deltaLongitude = 360.0f / numVerts;
            //Debug.Log($"Ring:{ringIndex} circumf={circumf} numVerts={ringcount[ringIndex]}");

            for (int vi=0; vi < numVerts; vi++)
            {
                rot = Quaternion.Euler(0.0f, deltaLongitude * vi, 0.0f);
                Vector3 v = rot * p;
                verts.Add(v);
            }
        }

        // tessellate inner disc (tri-strip)
        int n = ringcount[1];
        for (int i=0; i<n; i++)
        {
            inds.Add(0);
            inds.Add(1 + i);
            inds.Add(1 + ((i+1)%n));
        }

        // tessellate ring-bands
        for (int r=1; r<(numRings-1); r++)
        {
            // ring offset into verts array
            int off0 = ringoffset[r]; // inner
            int off1 = ringoffset[r + 1]; // outer

            // number of verts in ring
            int n0 = ringcount[r]; // inner
            int n1 = ringcount[r + 1]; // outer

            // normalized distance from verts within ring
            float s0 = 1.0f / n0; // inner
            float s1 = 1.0f / n1; // outer

            // current vertex index within each ring
            int i0 = 0; // inner
            int i1 = 0; // outer

            // next values
            float v0 = (i0 + 1) * s0;
            float v1 = (i1 + 1) * s1;

            while (true)
            {
                inds.Add(off0 + i0);
                inds.Add(off1 + i1);

                if (v0 < v1)
                {
                    // add a vertex from inner ring
                    i0++;
                    inds.Add(off0 + (i0 % n0));

                    if (i0 == n0)
                    {
                        inds.Add(off0);
                        inds.Add(off1 + i1);
                        inds.Add(off1);
                        break;
                    }
                    v0 = (i0 + 1) * s0;
                }
                else
                {
                    // add a vertex from outer ring
                    i1++;
                    inds.Add(off1 + (i1 % n1));

                    if (i1 == n1)
                    {
                        inds.Add(off0 + i0);
                        inds.Add(off1);
                        inds.Add(off0);
                        break;
                    }
                    v1 = (i1 + 1) * s1;
                }
            }
        }

        var mesh = new Mesh();
        mesh.name = name;

        mesh.vertices = verts.ToArray();
        //mesh.colors = colors.ToArray();
        mesh.SetIndices(inds.ToArray(), MeshTopology.Triangles, 0, true);
        meshFilter.sharedMesh = mesh;



    }

}