using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using MonoGame.Extended.Tiled;

namespace MonoGame.Extended.Tilemaps
{
    /// <summary>
    /// Represents a tilemap loaded from any supported format.
    /// </summary>
    /// <remarks>
    /// A tilemap is a collection of layers organized into a grid-based structure.
    /// Layers can contain tiles, objects, or images, and support various rendering
    /// features like parallax scrolling, opacity, and tinting.
    /// </remarks>
    public class Tilemap
    {
        /// <summary>
        /// Gets or sets the name of the tilemap.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Gets the width of the tilemap in tiles.
        /// </summary>
        public int Width { get; }

        /// <summary>
        /// Gets the height of the tilemap in tiles.
        /// </summary>
        public int Height { get; }

        /// <summary>
        /// Gets the width of each tile in pixels.
        /// </summary>
        public int TileWidth { get; }

        /// <summary>
        /// Gets the height of each tile in pixels.
        /// </summary>
        public int TileHeight { get; }

        /// <summary>
        /// Gets the orientation of the tilemap.
        /// </summary>
        public TilemapOrientation Orientation { get; }

        /// <summary>
        /// Gets or sets the background color of the tilemap.
        /// </summary>
        public Color? BackgroundColor { get; set; }

        /// <summary>
        /// Gets the custom properties of the tilemap.
        /// </summary>
        public TilemapProperties Properties { get; }

        /// <summary>
        /// Gets the collection of tilesets used by this tilemap.
        /// </summary>
        public TilemapTilesetCollection Tilesets { get; }

        /// <summary>
        /// Gets the collection of layers in this tilemap.
        /// </summary>
        public TilemapLayerCollection Layers { get; }

        /// <summary>
        /// Gets the world-space bounds of the tilemap.
        /// </summary>
        public Rectangle WorldBounds
        {
            get
            {
                // For orthogonal maps, bounds are straightforward
                // For isometric/hexagonal maps, this is an axis-aligned bounding box
                return Orientation switch
                {
                    TilemapOrientation.Orthogonal => new Rectangle(0, 0, Width * TileWidth, Height * TileHeight),

                    // Isometric maps have a diamond shape, so we need to calculate the AABB
                    TilemapOrientation.Isometric => CalculateIsometricBounds(),

                    // For staggered and hexagonal, use orthogonal approximation for now
                    // TODO: Implement precise bounds for staggered/hexagonal in future
                    TilemapOrientation.Staggered => new Rectangle(0, 0, Width * TileWidth, Height * TileHeight),
                    TilemapOrientation.Hexagonal => new Rectangle(0, 0, Width * TileWidth, Height * TileHeight),

                    _ => new Rectangle(0, 0, Width * TileWidth, Height * TileHeight)
                };
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Tilemap"/> class.
        /// </summary>
        /// <param name="name">The name of the tilemap.</param>
        /// <param name="width">The width of the tilemap in tiles.</param>
        /// <param name="height">The height of the tilemap in tiles.</param>
        /// <param name="tileWidth">The width of each tile in pixels.</param>
        /// <param name="tileHeight">The height of each tile in pixels.</param>
        /// <param name="orientation">The orientation of the tilemap.</param>
        public Tilemap(string name, int width, int height, int tileWidth, int tileHeight, TilemapOrientation orientation)
        {
            Name = name;
            Width = width;
            Height = height;
            TileWidth = tileWidth;
            TileHeight = tileHeight;
            Orientation = orientation;
            Properties = new TilemapProperties();
            Tilesets = new TilemapTilesetCollection();
            Layers = new TilemapLayerCollection();
        }

        /// <summary>
        /// Converts tile coordinates to world-space position.
        /// </summary>
        /// <param name="x">The tile X coordinate.</param>
        /// <param name="y">The tile Y coordinate.</param>
        /// <returns>The position in world space, where (0,0) represents the top-left corner of the map.</returns>
        /// <remarks>
        /// This transformation accounts for the map's orientation and tile dimensions.
        /// For isometric maps, the calculation differs from orthogonal maps.
        /// </remarks>
        public Point TileToWorldPosition(int x, int y)
        {
            return Orientation switch
            {
                TilemapOrientation.Orthogonal => TileToWorldOrthogonal(x, y),
                TilemapOrientation.Isometric => TileToWorldIsometric(x, y),
                TilemapOrientation.Staggered => TileToWorldStaggered(x, y),
                TilemapOrientation.Hexagonal => TileToWorldHexagonal(x, y),
                _ => TileToWorldOrthogonal(x, y)
            };
        }

        /// <summary>
        /// Converts world-space position to tile coordinates.
        /// </summary>
        /// <param name="worldPosition">The position in world space.</param>
        /// <returns>The tile coordinates.</returns>
        public Point WorldToTilePosition(Vector2 worldPosition)
        {
            return Orientation switch
            {
                TilemapOrientation.Orthogonal => WorldToTileOrthogonal(worldPosition),
                TilemapOrientation.Isometric => WorldToTileIsometric(worldPosition),
                TilemapOrientation.Staggered => WorldToTileStaggered(worldPosition),
                TilemapOrientation.Hexagonal => WorldToTileHexagonal(worldPosition),
                _ => WorldToTileOrthogonal(worldPosition),
            };
        }

        #region Helper Methods

        private Rectangle CalculateIsometricBounds()
        {
            // Isometric maps form a diamond shape
            // The width and height in world space are:
            // width = (mapWidth * mapHeight) * (tileWidth / 2)
            // height = (mapWidth * mapHeight) * (tileHeight / 2)
            int worldWidth = (Width + Height) * (TileWidth / 2);
            int worldHeight = (Width + Height) * (TileHeight / 2);

            return new Rectangle(0, 0, worldWidth, worldHeight);
        }

        private Point TileToWorldOrthogonal(int x, int y)
        {
            return new Point(x * TileWidth, y * TileHeight);
        }

        private Point TileToWorldIsometric(int x, int y)
        {
            // Isometric transformation:
            // worldX = (x - y) * (tileWidth / 2)
            // worldY = (x + y) * (tileHeight / 2)
            int worldX = (x - y) * (TileWidth / 2);
            int worldY = (x + y) * (TileHeight / 2);

            return new Point(worldX, worldY);
        }

        private Point TileToWorldStaggered(int x, int y)
        {
            // TODO: Implement staggered transformation in future
            // For now, use orthogonal as approximation
            return TileToWorldOrthogonal(x, y);
        }

        private Point TileToWorldHexagonal(int x, int y)
        {
            // TODO: Implement hexagonal transformation in future
            // For now, use orthogonal as approximation
            return TileToWorldOrthogonal(x, y);
        }

        private Point WorldToTileOrthogonal(Vector2 worldPosition)
        {
            int tileX = (int)(worldPosition.X / TileWidth);
            int tileY = (int)(worldPosition.Y / TileHeight);

            return new Point(tileX, tileY);
        }

        private Point WorldToTileIsometric(Vector2 worldPosition)
        {
            // Inverse isometric transformation:
            // x = (worldX / (tileWidth/2) + worldY / (tileHeight/2)) / 2
            // y = (worldY / (tileHeight/2) - worldX / (tileWidth/2)) / 2

            float halfTileWidth = TileWidth * 0.5f;
            float halfTileHeight = TileHeight * 0.5f;

            float normalizedX = worldPosition.X / halfTileWidth;
            float normalizedY = worldPosition.Y / halfTileHeight;

            int tileX = (int)((normalizedX + normalizedY) * 0.5f);
            int tileY = (int)((normalizedY - normalizedX) * 0.5f);

            return new Point(tileX, tileY);
        }

        private Point WorldToTileStaggered(Vector2 worldPosition)
        {
            // TODO: Implement staggered transformation in future
            // For now, use orthogonal as approximation
            return WorldToTileOrthogonal(worldPosition);
        }

        private Point WorldToTileHexagonal(Vector2 worldPosition)
        {
            // TODO: Implement hexagonal transformation in future
            // For now, use orthogonal as approximation
            return WorldToTileOrthogonal(worldPosition);
        }

        #endregion
    }
}