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

public class LevelLayoutGenerator : MonoBehaviour {

    public LevelModule starterRoom;
    public int iterCount;
    public int RNGSeed;
    public bool purgeExits; // MatchExits also deactivates them

    public LevelModule[] prefabList; // list of prefabs to choose from

    private Vector3 POS_ORIGIN = new Vector3(0f,0f,0f);

    private List<LevelModule> levelGraph = new List<LevelModule>(); // Spawned modules
    private List<ModuleExit> availableExits = new List<ModuleExit>(); // will hold the exits for each iteration


    void Start()
    {
        Debug.Log("Starting Level Generator");

        // SET THE RNG SEED
        //SetRandomGeneratorSeed();

        // Place starter room in the graph and add its exits
        LevelModule starter = (LevelModule)Instantiate(starterRoom,transform.position,transform.rotation);
        LevelModule oldModule = starter;

        availableExits.AddRange(starter.GetExitList());

        // SET THE RNG SEED MANUALLY
        Random.InitState(RNGSeed);

        // Start the iteration loop to fill exits
        for (int iter = 0; iter <= iterCount; iter++)
        {
            //yield return new WaitForSeconds(1);

            List<ModuleExit> newExits = new List<ModuleExit>();

            // Add a random prefab room to each available exit in the graph
            foreach (ModuleExit currExit in availableExits)
            {
                // Spawn a random prefab for the selected exit, push to newExits and mark them as connected
                LevelModule newModule = ChooseRandomModule(prefabList);

                newModule = (LevelModule)Instantiate(newModule);
                newExits.AddRange(newModule.GetExitList());

                ModuleExit newExit = ChooseRandomExit(newModule.GetExitList());

                MatchExits(currExit,newExit,purgeExits);

                // Check for collision

            }

            // Replace the initial available exits with the new list
            RebuildExitList(newExits);
        }
    }

    // METHODS

    LevelModule ChooseRandomModule(LevelModule[] prefabs)
    {
        int index;

        index = Random.Range(0,prefabs.Length);

        return prefabs[index];
    }

    ModuleExit ChooseRandomExit(ModuleExit[] exit)
    {
        int index;

        index = Random.Range(0, exit.Length);

        return exit[index];
    }



    void SetRandomGeneratorSeed() // Sets seed to a known function
    {
        // This chooses the seed method
        Random.InitState(System.DateTime.Now.Millisecond);

    }


    void SetRandomGeneratorSeed(int seed) // When seed is provided
    {
        Random.InitState(seed);
    }

    private static float Azimuth(Vector3 vector)
    {
        return Vector3.Angle(Vector3.forward, vector) * Mathf.Sign(vector.x);
    }

    private void MatchExits(ModuleExit oldExit, ModuleExit newExit, bool purge)
    {
        var newModule = newExit.transform.parent;
        var forwardVectorToMatch = -oldExit.transform.forward;
        var correctiveRotation = Azimuth(forwardVectorToMatch) - Azimuth(newExit.transform.forward);
        newModule.RotateAround(newExit.transform.position, Vector3.up, correctiveRotation);
        var correctiveTranslation = oldExit.transform.position - newExit.transform.position;
        newModule.transform.position += correctiveTranslation;

        // Deactivate exits test functionality
        if (purge)
        {
            newExit.enabled = false;
            oldExit.enabled = false;

            Destroy(newExit);
            Destroy(oldExit);
        }
    }

    private void RebuildExitList(List<ModuleExit> newEx)
    {
        availableExits.Clear();

        foreach (ModuleExit ex in newEx)
        {
            if (!ex.isMatched)
            {
                availableExits.Add(ex);
            }
        }
    }

    private bool CheckOverlaps(LevelModule newModule, ModuleExit oldExit)
    {
        // Ignores the new and old modules and checks for overlaps
        // with other objects

        LevelModule oldModule = oldExit.GetComponentInParent<LevelModule>();

        if (oldModule == null)
        {
            Debug.Log("Can't find a LevelModule component in this exit!");
        }

        // Set a temporary ignore mask for both
        int ignoreMask = LayerMask.GetMask("TempIgnoreCollision");

        newModule.gameObject.layer = ignoreMask;
        oldModule.gameObject.layer = ignoreMask;

        Collider[] newColliders = Physics.OverlapBox(newModule.transform.position, transform.localScale / 2, transform.rotation,ignoreMask);

        if (newColliders.Length != 0 )
        {
            return true;
        }

        else
            return false;
    }
}