using UnityEngine;

/// <summary>
/// Main controller for maze generation and management
/// </summary>
public class MazeController : MonoBehaviour
{
    [SerializeField] private MazeConfig mazeConfig = new();
    [SerializeField] private bool generateOnStart = true;
    [SerializeField] private bool visualizeDebug = true;

    [Header("Renderers")]
    [SerializeField] private MazeRenderer mazeRenderer;
    [SerializeField] private ChunkedMazeRenderer chunkedRenderer;
    [SerializeField] private MeshMazeRenderer meshMazeRenderer;

    private MazeData currentMaze;
    private MazeGenerator generator;

    void Start()
    {
        if (mazeRenderer == null)
        {
            mazeRenderer = GetComponent<MazeRenderer>() ?? FindFirstObjectByType<MazeRenderer>();
        }
        if (chunkedRenderer == null)
        {
            chunkedRenderer = GetComponent<ChunkedMazeRenderer>() ?? FindFirstObjectByType<ChunkedMazeRenderer>();
        }
        if (meshMazeRenderer == null)
        {
            meshMazeRenderer = GetComponent<MeshMazeRenderer>() ?? FindFirstObjectByType<MeshMazeRenderer>();
        }

        if (generateOnStart)
        {
            GenerateMaze();
        }
    }

    /// <summary>
    /// Generates a new maze using the current configuration
    /// </summary>
    public void GenerateMaze()
    {
        Debug.Log("Generating maze...");
        generator = new MazeGenerator(mazeConfig);
        currentMaze = generator.Generate();

        if (visualizeDebug)
        {
            VisualizeMaze();
        }

        if (mazeRenderer != null)
        {
            mazeRenderer.RenderMaze();
        }

        if (chunkedRenderer != null)
        {
            chunkedRenderer.RefreshVisibleChunks();
        }

        if (meshMazeRenderer != null)
        {
            meshMazeRenderer.RefreshMesh();
        }
    }

    /// <summary>
    /// Visualizes the maze in the editor/game for debugging
    /// </summary>
    private void VisualizeMaze()
    {
        if (currentMaze == null) return;

        // Draw grid visualization in Scene view
        for (int x = 0; x < currentMaze.Width; x += 10)
        {
            Debug.DrawLine(new Vector3(x, 0, 0), new Vector3(x, currentMaze.Height, 0), Color.gray);
        }
        for (int y = 0; y < currentMaze.Height; y += 10)
        {
            Debug.DrawLine(new Vector3(0, y, 0), new Vector3(currentMaze.Width, y, 0), Color.gray);
        }

        // Highlight start and exit points
        foreach (var start in currentMaze.StartPoints)
        {
            Debug.DrawLine(new Vector3(start.x - 0.5f, start.y - 0.5f, 0),
                          new Vector3(start.x + 0.5f, start.y + 0.5f, 0), Color.green);
        }

        foreach (var exit in currentMaze.ExitPoints)
        {
            Debug.DrawLine(new Vector3(exit.x - 0.5f, exit.y - 0.5f, 0),
                          new Vector3(exit.x + 0.5f, exit.y + 0.5f, 0), Color.red);
        }
    }

    /// <summary>
    /// Gets the current maze data
    /// </summary>
    public MazeData GetCurrentMaze()
    {
        return currentMaze;
    }

    /// <summary>
    /// Sets the current maze data (used by async generators)
    /// </summary>
    public void SetCurrentMaze(MazeData maze)
    {
        currentMaze = maze;

        if (visualizeDebug)
        {
            VisualizeMaze();
        }

        // Render the maze using available renderers
        var renderer = GetComponent<MazeRenderer>();
        if (renderer != null)
        {
            renderer.RenderMaze();
        }

        var chunkedRenderer = GetComponent<ChunkedMazeRenderer>();
        if (chunkedRenderer != null)
        {
            chunkedRenderer.RefreshVisibleChunks();
        }

        var meshRenderer = GetComponent<MeshMazeRenderer>();
        if (meshRenderer != null)
        {
            meshRenderer.RefreshMesh();
        }
    }

    /// <summary>
    /// Gets the current maze configuration
    /// </summary>
    public MazeConfig GetConfig()
    {
        return mazeConfig;
    }

    /// <summary>
    /// Gets a tile at specific coordinates
    /// </summary>
    public MazeTile GetTile(int x, int y)
    {
        return currentMaze?.GetTile(x, y);
    }

    /// <summary>
    /// Checks if a position is walkable
    /// </summary>
    public bool IsWalkable(int x, int y)
    {
        return currentMaze?.IsWalkable(x, y) ?? false;
    }

    /// <summary>
    /// Gets the room at a specific tile position
    /// </summary>
    public MazeRoom GetRoomAtTile(int x, int y)
    {
        return currentMaze?.GetRoomAtTile(x, y);
    }

    /// <summary>
    /// Gets all start points
    /// </summary>
    public System.Collections.Generic.List<Vector2Int> GetStartPoints()
    {
        return currentMaze?.StartPoints ?? new();
    }

    /// <summary>
    /// Gets all exit points
    /// </summary>
    public System.Collections.Generic.List<Vector2Int> GetExitPoints()
    {
        return currentMaze?.ExitPoints ?? new();
    }

    void Update()
    {
        // Can be used for real-time generation or maze editing later
    }
}