using AcDream.Core.Textures;
using DatReaderWriter;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Enums;
using Silk.NET.OpenGL;
using DatPixelFormat = DatReaderWriter.Enums.PixelFormat;
using GLPixelFormat = Silk.NET.OpenGL.PixelFormat;

namespace AcDream.App.Rendering;

/// <summary>
/// Holds both texture arrays the terrain renderer samples from:
/// <list type="bullet">
///   <item><description>
///     <b>Terrain atlas</b> — one GL_TEXTURE_2D_ARRAY layer per terrain type
///     (grass, dirt, sand, forest...), sourced from
///     Region.TerrainInfo.LandSurfaces.TexMerge.TerrainDesc.
///   </description></item>
///   <item><description>
///     <b>Alpha atlas</b> — one GL_TEXTURE_2D_ARRAY layer per blend mask,
///     sourced from CornerTerrainMaps / SideTerrainMaps / RoadMaps in the
///     same TexMerge. Used by the fragment shader to blend up to three
///     terrain overlays and two roads on top of a base cell texture.
///   </description></item>
/// </list>
/// The alpha atlas is built but not yet sampled by any shader — that wiring
/// lands in Phase 3c.4 along with the shader rewrite.
/// </summary>
public sealed unsafe class TerrainAtlas : IDisposable
{
    private readonly GL _gl;

    // --- Terrain atlas (unchanged public API from Phase 2b) ---
    public uint GlTexture { get; }  // terrain atlas, kept as GlTexture for back-compat with TerrainRenderer
    public IReadOnlyDictionary<uint, uint> TerrainTypeToLayer { get; }
    public int LayerCount { get; }

    // --- Alpha atlas (new in Phase 3c.2) ---
    public uint GlAlphaTexture { get; }
    public int AlphaLayerCount { get; }
    /// <summary>Layer indices in the alpha atlas for CornerTerrainMaps (typically 4 entries).</summary>
    public IReadOnlyList<byte> CornerAlphaLayers { get; }
    /// <summary>Layer indices in the alpha atlas for SideTerrainMaps (typically 4 entries).</summary>
    public IReadOnlyList<byte> SideAlphaLayers { get; }
    /// <summary>Layer indices in the alpha atlas for RoadMaps (variable count).</summary>
    public IReadOnlyList<byte> RoadAlphaLayers { get; }

    // --- Parallel TCode/RCode arrays (added in Phase 3c.4 for BuildSurface) ---
    /// <summary>TCode for each CornerTerrainMap, parallel to <see cref="CornerAlphaLayers"/>.</summary>
    public IReadOnlyList<uint> CornerAlphaTCodes { get; }
    /// <summary>TCode for each SideTerrainMap, parallel to <see cref="SideAlphaLayers"/>.</summary>
    public IReadOnlyList<uint> SideAlphaTCodes { get; }
    /// <summary>RCode for each RoadMap, parallel to <see cref="RoadAlphaLayers"/>.</summary>
    public IReadOnlyList<uint> RoadAlphaRCodes { get; }

    private readonly Wb.BindlessSupport? _bindless;

    // Cached bindless handles. Generated lazily on first GetBindlessHandles() call;
    // reused for the lifetime of the atlas.
    private ulong _terrainHandle;
    private ulong _alphaHandle;
    private bool  _handlesGenerated;

    /// <summary>
    /// Get 64-bit bindless handles for the terrain + alpha texture arrays.
    /// Throws <see cref="InvalidOperationException"/> if the atlas was constructed
    /// without a <see cref="Wb.BindlessSupport"/> instance. Handles are generated
    /// lazily on first call and cached for the atlas's lifetime; both textures
    /// are made resident.
    /// </summary>
    public (ulong terrain, ulong alpha) GetBindlessHandles()
    {
        if (_bindless is null)
            throw new InvalidOperationException(
                "TerrainAtlas was constructed without BindlessSupport; cannot return bindless handles.");
        if (!_handlesGenerated)
        {
            _terrainHandle = _bindless.GetResidentHandle(GlTexture);
            _alphaHandle   = _bindless.GetResidentHandle(GlAlphaTexture);
            _handlesGenerated = true;
        }
        return (_terrainHandle, _alphaHandle);
    }

    private TerrainAtlas(
        GL gl,
        Wb.BindlessSupport? bindless,
        uint glTexture, IReadOnlyDictionary<uint, uint> map, int layerCount,
        uint glAlphaTexture, int alphaLayerCount,
        IReadOnlyList<byte> cornerLayers, IReadOnlyList<byte> sideLayers, IReadOnlyList<byte> roadLayers,
        IReadOnlyList<uint> cornerTCodes, IReadOnlyList<uint> sideTCodes, IReadOnlyList<uint> roadRCodes)
    {
        _gl = gl;
        _bindless = bindless;
        GlTexture = glTexture;
        TerrainTypeToLayer = map;
        LayerCount = layerCount;
        GlAlphaTexture = glAlphaTexture;
        AlphaLayerCount = alphaLayerCount;
        CornerAlphaLayers = cornerLayers;
        SideAlphaLayers = sideLayers;
        RoadAlphaLayers = roadLayers;
        CornerAlphaTCodes = cornerTCodes;
        SideAlphaTCodes = sideTCodes;
        RoadAlphaRCodes = roadRCodes;
    }

    /// <summary>
    /// Build the atlas by walking Region.TerrainInfo.LandSurfaces.TexMerge.TerrainDesc
    /// for the mapping from TerrainTextureType to SurfaceTexture id, decoding each
    /// to RGBA8, and uploading as layers in a single GL_TEXTURE_2D_ARRAY.
    /// </summary>
    public static TerrainAtlas Build(GL gl, DatCollection dats, Wb.BindlessSupport? bindless = null)
    {
        var region = dats.Get<Region>(0x13000000u)
            ?? throw new InvalidOperationException("Region dat id 0x13000000 missing");

        var texMerge = region.TerrainInfo?.LandSurfaces?.TexMerge;
        var terrainDesc = texMerge?.TerrainDesc;
        if (terrainDesc is null || terrainDesc.Count == 0)
        {
            Console.WriteLine("WARN: TerrainDesc missing, using single white fallback layer");
            return BuildFallback(gl, bindless);
        }

        // ---- Terrain atlas (unchanged Phase 2b logic) ----
        var decodedByType = new Dictionary<uint, DecodedTexture>();
        int maxW = 1, maxH = 1;
        foreach (var tmtd in terrainDesc)
        {
            uint typeKey = (uint)tmtd.TerrainType;
            if (decodedByType.ContainsKey(typeKey))
                continue;

            var surfaceTextureId = (uint)tmtd.TerrainTex.TextureId;
            var st = dats.Get<SurfaceTexture>(surfaceTextureId);
            if (st is null || st.Textures.Count == 0)
            {
                Console.WriteLine($"WARN: TerrainType {tmtd.TerrainType} SurfaceTexture 0x{surfaceTextureId:X8} missing");
                decodedByType[typeKey] = DecodedTexture.Magenta;
                continue;
            }

            var rs = dats.Get<RenderSurface>((uint)st.Textures[0]);
            if (rs is null)
            {
                decodedByType[typeKey] = DecodedTexture.Magenta;
                continue;
            }

            Palette? palette = rs.DefaultPaletteId != 0
                ? dats.Get<Palette>(rs.DefaultPaletteId)
                : null;

            var decoded = SurfaceDecoder.DecodeRenderSurface(rs, palette);
            decodedByType[typeKey] = decoded;
            if (decoded.Width > maxW) maxW = decoded.Width;
            if (decoded.Height > maxH) maxH = decoded.Height;
        }

        int layerCount = decodedByType.Count;
        uint tex = gl.GenTexture();
        gl.BindTexture(TextureTarget.Texture2DArray, tex);
        gl.TexImage3D(
            TextureTarget.Texture2DArray, 0, InternalFormat.Rgba8,
            (uint)maxW, (uint)maxH, (uint)layerCount,
            0, GLPixelFormat.Rgba, PixelType.UnsignedByte, null);

        var map = new Dictionary<uint, uint>();
        int layerIdx = 0;
        foreach (var kvp in decodedByType)
        {
            byte[] buffer = ResizeRgba8Nearest(kvp.Value, maxW, maxH);
            fixed (byte* p = buffer)
            {
                gl.TexSubImage3D(
                    TextureTarget.Texture2DArray, 0,
                    0, 0, layerIdx,
                    (uint)maxW, (uint)maxH, 1,
                    GLPixelFormat.Rgba, PixelType.UnsignedByte, p);
            }
            map[kvp.Key] = (uint)layerIdx;
            layerIdx++;
        }

        // A.5 T19: generate mipmaps + trilinear + 16x anisotropic for distant-LB quality.
        gl.GenerateMipmap(TextureTarget.Texture2DArray);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
        // GL_TEXTURE_MAX_ANISOTROPY = 0x84FE (GL_EXT_texture_filter_anisotropic / ARB_texture_filter_anisotropic).
        gl.TexParameter(TextureTarget.Texture2DArray, (TextureParameterName)0x84FE, 16.0f);
        gl.BindTexture(TextureTarget.Texture2DArray, 0);

        Console.WriteLine($"TerrainAtlas: {layerCount} terrain layers at {maxW}x{maxH} (mipmaps+aniso16x)");

        // ---- Alpha atlas (new in Phase 3c.2) ----
        // texMerge is guaranteed non-null here: the early return above exited
        // if texMerge?.TerrainDesc was null.
        var alphaBuild = BuildAlphaAtlas(gl, dats, texMerge!);

        return new TerrainAtlas(
            gl,
            bindless,
            tex, map, layerCount,
            alphaBuild.gl, alphaBuild.layerCount,
            alphaBuild.corner, alphaBuild.side, alphaBuild.road,
            alphaBuild.cornerTCodes, alphaBuild.sideTCodes, alphaBuild.roadRCodes);
    }

    /// <summary>
    /// Load corner, side, and road alpha maps from the TexMerge into a second
    /// GL_TEXTURE_2D_ARRAY. AC ships these as 512×512 PFID_A8 textures;
    /// <see cref="SurfaceDecoder.DecodeRenderSurface"/> expands each alpha byte
    /// into all four RGBA channels so the shader can sample from any channel.
    ///
    /// Layers are appended in TexMerge insertion order: corners first, then
    /// sides, then roads. The returned index lists tell
    /// <c>TerrainBlending.BuildSurface</c> which layer to cite for each
    /// corner/side/road alpha source.
    /// </summary>
    private readonly record struct AlphaAtlasBuildResult(
        uint gl, int layerCount,
        IReadOnlyList<byte> corner, IReadOnlyList<byte> side, IReadOnlyList<byte> road,
        IReadOnlyList<uint> cornerTCodes, IReadOnlyList<uint> sideTCodes, IReadOnlyList<uint> roadRCodes);

    private static AlphaAtlasBuildResult BuildAlphaAtlas(
        GL gl, DatCollection dats, DatReaderWriter.Types.TexMerge texMerge)
    {
        var decoded = new List<DecodedTexture>();
        var cornerLayers = new List<byte>();
        var sideLayers = new List<byte>();
        var roadLayers = new List<byte>();
        var cornerTCodes = new List<uint>();
        var sideTCodes = new List<uint>();
        var roadRCodes = new List<uint>();

        foreach (var entry in texMerge.CornerTerrainMaps)
        {
            if (TryDecodeAlphaMap(dats, (uint)entry.TextureId, out var dtex))
            {
                cornerLayers.Add((byte)decoded.Count);
                cornerTCodes.Add(entry.TCode);
                decoded.Add(dtex);
            }
            else
            {
                Console.WriteLine($"WARN: CornerTerrainMap TextureId 0x{(uint)entry.TextureId:X8} failed to decode");
            }
        }
        foreach (var entry in texMerge.SideTerrainMaps)
        {
            if (TryDecodeAlphaMap(dats, (uint)entry.TextureId, out var dtex))
            {
                sideLayers.Add((byte)decoded.Count);
                sideTCodes.Add(entry.TCode);
                decoded.Add(dtex);
            }
            else
            {
                Console.WriteLine($"WARN: SideTerrainMap TextureId 0x{(uint)entry.TextureId:X8} failed to decode");
            }
        }
        foreach (var entry in texMerge.RoadMaps)
        {
            if (TryDecodeAlphaMap(dats, (uint)entry.TextureId, out var dtex))
            {
                roadLayers.Add((byte)decoded.Count);
                roadRCodes.Add(entry.RCode);
                decoded.Add(dtex);
            }
            else
            {
                Console.WriteLine($"WARN: RoadMap TextureId 0x{(uint)entry.TextureId:X8} failed to decode");
            }
        }

        if (decoded.Count == 0)
        {
            Console.WriteLine("WARN: no alpha maps loaded; alpha atlas will be a 1x1 white fallback");
            uint fallbackAlpha = gl.GenTexture();
            gl.BindTexture(TextureTarget.Texture2DArray, fallbackAlpha);
            gl.TexImage3D(TextureTarget.Texture2DArray, 0, InternalFormat.Rgba8, 1, 1, 1, 0,
                GLPixelFormat.Rgba, PixelType.UnsignedByte, null);
            var white = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
            fixed (byte* p = white)
                gl.TexSubImage3D(TextureTarget.Texture2DArray, 0, 0, 0, 0, 1, 1, 1,
                    GLPixelFormat.Rgba, PixelType.UnsignedByte, p);
            gl.BindTexture(TextureTarget.Texture2DArray, 0);
            return new AlphaAtlasBuildResult(
                fallbackAlpha, 1,
                cornerLayers, sideLayers, roadLayers,
                cornerTCodes, sideTCodes, roadRCodes);
        }

        // Alpha maps should all be uniform size (WorldBuilder asserts 512×512).
        // Fall back to the max observed so a stray mismatch doesn't crash us.
        int aMaxW = 1, aMaxH = 1;
        foreach (var d in decoded)
        {
            if (d.Width > aMaxW) aMaxW = d.Width;
            if (d.Height > aMaxH) aMaxH = d.Height;
        }

        uint glAlpha = gl.GenTexture();
        gl.BindTexture(TextureTarget.Texture2DArray, glAlpha);
        gl.TexImage3D(
            TextureTarget.Texture2DArray, 0, InternalFormat.Rgba8,
            (uint)aMaxW, (uint)aMaxH, (uint)decoded.Count,
            0, GLPixelFormat.Rgba, PixelType.UnsignedByte, null);

        for (int i = 0; i < decoded.Count; i++)
        {
            var buffer = ResizeRgba8Nearest(decoded[i], aMaxW, aMaxH);
            fixed (byte* p = buffer)
            {
                gl.TexSubImage3D(
                    TextureTarget.Texture2DArray, 0,
                    0, 0, i,
                    (uint)aMaxW, (uint)aMaxH, 1,
                    GLPixelFormat.Rgba, PixelType.UnsignedByte, p);
            }
        }

        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
        gl.BindTexture(TextureTarget.Texture2DArray, 0);

        Console.WriteLine(
            $"AlphaAtlas: {decoded.Count} layers at {aMaxW}x{aMaxH}  "
            + $"(corners={cornerLayers.Count}, sides={sideLayers.Count}, roads={roadLayers.Count})");

        return new AlphaAtlasBuildResult(
            glAlpha, decoded.Count,
            cornerLayers, sideLayers, roadLayers,
            cornerTCodes, sideTCodes, roadRCodes);
    }

    private static bool TryDecodeAlphaMap(DatCollection dats, uint surfaceTextureId, out DecodedTexture decoded)
    {
        decoded = DecodedTexture.Magenta;

        var st = dats.Get<SurfaceTexture>(surfaceTextureId);
        if (st is null || st.Textures.Count == 0)
            return false;

        var rs = dats.Get<RenderSurface>((uint)st.Textures[0]);
        if (rs is null)
            return false;

        // Alpha maps ship as PFID_CUSTOM_LSCAPE_ALPHA (AC's landscape-alpha
        // format) or the more generic PFID_A8; terrain blending alpha masks
        // MUST use isAdditive=true so R=G=B=A=val — the terrain fragment shader
        // reads .r for the blend weight. Palette is not used.
        var d = SurfaceDecoder.DecodeRenderSurface(rs, palette: null, isClipMap: false, isAdditive: true);
        if (ReferenceEquals(d, DecodedTexture.Magenta))
            return false;

        decoded = d;
        return true;
    }

    private static byte[] ResizeRgba8Nearest(DecodedTexture src, int dstW, int dstH)
    {
        if (src.Width == dstW && src.Height == dstH)
            return src.Rgba8;

        var dst = new byte[dstW * dstH * 4];
        for (int y = 0; y < dstH; y++)
        {
            int srcY = y * src.Height / dstH;
            for (int x = 0; x < dstW; x++)
            {
                int srcX = x * src.Width / dstW;
                int si = (srcY * src.Width + srcX) * 4;
                int di = (y * dstW + x) * 4;
                dst[di + 0] = src.Rgba8[si + 0];
                dst[di + 1] = src.Rgba8[si + 1];
                dst[di + 2] = src.Rgba8[si + 2];
                dst[di + 3] = src.Rgba8[si + 3];
            }
        }
        return dst;
    }

    private static TerrainAtlas BuildFallback(GL gl, Wb.BindlessSupport? bindless = null)
    {
        uint tex = gl.GenTexture();
        gl.BindTexture(TextureTarget.Texture2DArray, tex);
        var white = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
        gl.TexImage3D(TextureTarget.Texture2DArray, 0, InternalFormat.Rgba8, 1, 1, 1, 0, GLPixelFormat.Rgba, PixelType.UnsignedByte, null);
        fixed (byte* p = white)
            gl.TexSubImage3D(TextureTarget.Texture2DArray, 0, 0, 0, 0, 1, 1, 1, GLPixelFormat.Rgba, PixelType.UnsignedByte, p);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
        gl.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
        gl.BindTexture(TextureTarget.Texture2DArray, 0);

        // Fallback alpha atlas: 1x1 white, no layers tracked
        uint alphaTex = gl.GenTexture();
        gl.BindTexture(TextureTarget.Texture2DArray, alphaTex);
        gl.TexImage3D(TextureTarget.Texture2DArray, 0, InternalFormat.Rgba8, 1, 1, 1, 0, GLPixelFormat.Rgba, PixelType.UnsignedByte, null);
        fixed (byte* p = white)
            gl.TexSubImage3D(TextureTarget.Texture2DArray, 0, 0, 0, 0, 1, 1, 1, GLPixelFormat.Rgba, PixelType.UnsignedByte, p);
        gl.BindTexture(TextureTarget.Texture2DArray, 0);

        return new TerrainAtlas(
            gl,
            bindless,
            tex, new Dictionary<uint, uint> { [0] = 0u }, 1,
            alphaTex, 1,
            Array.Empty<byte>(), Array.Empty<byte>(), Array.Empty<byte>(),
            Array.Empty<uint>(), Array.Empty<uint>(), Array.Empty<uint>());
    }

    /// <summary>
    /// A.5 T22.5: update GL_TEXTURE_MAX_ANISOTROPY on the terrain atlas at
    /// runtime (called by <see cref="GameWindow.ReapplyQualityPreset"/> when
    /// the user changes Quality preset mid-session). Idempotent — calling with
    /// the same level as the current setting is safe and produces no visual
    /// change. The texture must not be resident-bindless when its parameters
    /// are mutated; we temporarily make it non-resident if needed.
    /// </summary>
    public void SetAnisotropic(int level)
    {
        // If bindless handles are live we must make them non-resident before
        // mutating texture state, then re-resident after.
        bool wasResident = _handlesGenerated && _bindless is not null;
        if (wasResident)
        {
            _bindless!.MakeNonResident(_terrainHandle);
            // Alpha texture is not affected by anisotropic but we must keep
            // residency symmetric — re-generate both handles after.
            _bindless.MakeNonResident(_alphaHandle);
            _handlesGenerated = false;
        }

        _gl.BindTexture(TextureTarget.Texture2DArray, GlTexture);
        // GL_TEXTURE_MAX_ANISOTROPY = 0x84FE
        _gl.TexParameter(TextureTarget.Texture2DArray, (TextureParameterName)0x84FE, (float)level);
        _gl.BindTexture(TextureTarget.Texture2DArray, 0);

        // Re-generate bindless handles if they were live before.
        if (wasResident)
        {
            // GetBindlessHandles regenerates and makes resident.
            _ = GetBindlessHandles();
        }

        Console.WriteLine($"TerrainAtlas: anisotropic updated to {level}x");
    }

    public void Dispose()
    {
        // Phase 1: release bindless residency BEFORE deleting textures.
        // ARB_bindless_texture requires this ordering; interleaving is UB.
        if (_handlesGenerated && _bindless is not null)
        {
            _bindless.MakeNonResident(_terrainHandle);
            _bindless.MakeNonResident(_alphaHandle);
            _handlesGenerated = false;
        }

        // Phase 2: delete the underlying GL textures.
        _gl.DeleteTexture(GlTexture);
        _gl.DeleteTexture(GlAlphaTexture);
    }
}