using System.Numerics;
using System.Text;
using BlitzKit.Game.JSExport;
using CUE4Parse_Conversion;
using CUE4Parse_Conversion.Materials;
using CUE4Parse_Conversion.Meshes;
using CUE4Parse_Conversion.Meshes.glTF;
using CUE4Parse_Conversion.Meshes.PSK;
using CUE4Parse_Conversion.Textures;
using CUE4Parse.UE4.Assets.Exports.Material;
using CUE4Parse.UE4.Assets.Exports.StaticMesh;
using CUE4Parse.UE4.Assets.Exports.Texture;
using CUE4Parse.UE4.Objects.Core.Math;
using CUE4Parse.UE4.Objects.Meshes;
using SharpGLTF.Geometry;
using SharpGLTF.Geometry.VertexTypes;
using SharpGLTF.Materials;
using SharpGLTF.Memory;
using SharpGLTF.Scenes;
using SharpGLTF.Schema2;
using SharpGLTF.Validation;

namespace BlitzKit.Game.Models;

using ConfiguredMeshBuilder = MeshBuilder<
  VertexPositionNormalTangent,
  VertexColorXTextureX,
  VertexEmpty
>;

public class MonoGltf
{
  readonly SceneBuilder scene = new();

  public static readonly Dictionary<string, KnownChannel> knownChannels = new()
  {
    { "BaseColor", KnownChannel.BaseColor },
    { "Normal", KnownChannel.Normal },
    { "RMAO", KnownChannel.MetallicRoughness },
    // { "CDE", ?? },
  };
  readonly byte[] stubBytes = File.ReadAllBytes("../game/stub/small.png");

  public MonoGltf(List<UStaticMesh> meshes)
  {
    var options = new ExporterOptions() { TextureFormat = ETextureFormat.Jpeg };

    foreach (var mesh in meshes)
    {
      mesh.TryConvert(out var converted);
      var lod0 =
        converted.LODs.Find(lod => !lod.SkipLod) ?? throw new Exception("Failed to find lod0");

      var emptyMaterial = new MaterialBuilder("empty_material");
      var materialMap = new Dictionary<string, MaterialBuilder>();

      int sectionIndex = 0;
      foreach (var section in lod0.Sections.Value)
      {
        var meshBuilder = new ConfiguredMeshBuilder();
        MaterialBuilder materialBuilder;

        if (section.Material == null || section.MaterialName == null)
        {
          materialBuilder = emptyMaterial;
        }
        else if (materialMap.TryGetValue(section.MaterialName, out MaterialBuilder? value))
        {
          materialBuilder = value;
        }
        else
        {
          var materialInterface = section.Material.Load<UMaterialInterface>()!;
          var materialData = new MaterialData() { Parameters = new() };

          materialInterface.GetParams(materialData.Parameters, options.MaterialFormat);
          materialBuilder = new();
          materialMap.Add(section.MaterialName, materialBuilder);

          foreach (var parameterTexture in materialData.Parameters.Textures)
          {
            if (knownChannels.TryGetValue(parameterTexture.Key, out var channel))
            {
              var texture = parameterTexture.Value;
              var name = Path.GetFileNameWithoutExtension(texture.GetPathName());
              var path = $"../../../textures/{name}.webp";

              var lastIndex = stubBytes.Length - 1;
              stubBytes[lastIndex] = (byte)(++stubBytes[lastIndex] % 255);
              var uniqueBytes = (byte[])stubBytes.Clone();
              var stubImage = new MemoryImage(uniqueBytes);

              // Console.WriteLine(
              //   $"created stub image {stubImage} @ {stubImage.SourcePath} w/ byte {uniqueBytes[lastIndex]}"
              // );

              materialBuilder.WithChannelImage(channel, stubImage);
              materialBuilder.GetChannel(channel).Texture.PrimaryImage.Name = path;
            }
            else
            {
              // Console.WriteLine($"Unsupported texture type: {parameterTexture.Key}");
            }
          }
        }

        var primitive = meshBuilder.UsePrimitive(materialBuilder);

        for (int faceIndex = 0; faceIndex < section.NumFaces; faceIndex++)
        {
          var wedgeIndex = new int[3];
          for (var k = 0; k < wedgeIndex.Length; k++)
          {
            wedgeIndex[k] = (int)lod0.Indices.Value[section.FirstIndex + faceIndex * 3 + k];
          }

          var vertex1 = lod0.Verts[wedgeIndex[0]];
          var vertex2 = lod0.Verts[wedgeIndex[1]];
          var vertex3 = lod0.Verts[wedgeIndex[2]];

          var (v1, v2, v3) = PrepareTris(vertex1, vertex2, vertex3);
          var (c1, c2, c3) = PrepareUVsAndTexCoords(lod0, vertex1, vertex2, vertex3, wedgeIndex);

          primitive.AddTriangle((v1, c1), (v2, c2), (v3, c3));
        }

        scene.AddRigidMesh(meshBuilder, Matrix4x4.Identity);
      }
    }
  }

  public byte[] Write(string name)
  {
    var model = scene.ToGltf2();

    model.Asset.Copyright = null;
    model.Asset.Generator = null;

    var mappedTextures = new Dictionary<MemoryImage, string>();

    // Console.WriteLine($"found {model.LogicalImages.Count} logical images");

    foreach (var image in model.LogicalImages)
    {
      // Console.WriteLine($"mapping {image.Content} ({image.Name})");
      mappedTextures[image.Content] = image.Name!;
      image.Name = null;
    }

    var stream = new MemoryStream();
    var context = WriteContext
      .CreateFromStream(stream)
      .WithSettingsFrom(
        new()
        {
          ImageWriting = ResourceWriteMode.SatelliteFile,
          ImageWriteCallback = (context, assetName, image) =>
          {
            // Console.WriteLine($"got {image} -> {mappedTextures[image]}");

            return mappedTextures[image];
          },
        }
      );

    context.WriteBinarySchema2(name, model);

    return stream.ToArray();
  }

  private static (
    VertexPositionNormalTangent,
    VertexPositionNormalTangent,
    VertexPositionNormalTangent
  ) PrepareTris(CMeshVertex vert1, CMeshVertex vert2, CMeshVertex vert3)
  {
    var v1 = new VertexPositionNormalTangent(
      SwapYZ(vert1.Position * 0.01f),
      SwapYZAndNormalize((FVector)vert1.Normal),
      SwapYZAndNormalize((Vector4)vert1.Tangent)
    );
    var v2 = new VertexPositionNormalTangent(
      SwapYZ(vert2.Position * 0.01f),
      SwapYZAndNormalize((FVector)vert2.Normal),
      SwapYZAndNormalize((Vector4)vert2.Tangent)
    );
    var v3 = new VertexPositionNormalTangent(
      SwapYZ(vert3.Position * 0.01f),
      SwapYZAndNormalize((FVector)vert3.Normal),
      SwapYZAndNormalize((Vector4)vert3.Tangent)
    );

    return (v1, v2, v3);
  }

  public static FVector SwapYZ(FVector vec)
  {
    var res = new FVector(vec.X, vec.Z, vec.Y);
    return res;
  }

  public static FVector SwapYZAndNormalize(FVector vec)
  {
    var res = SwapYZ(vec);
    res.Normalize();
    return res;
  }

  public static Vector4 SwapYZAndNormalize(Vector4 vec)
  {
    return Vector4.Normalize(new Vector4(vec.X, vec.Z, vec.Y, vec.W));
  }

  public static (
    VertexColorXTextureX,
    VertexColorXTextureX,
    VertexColorXTextureX
  ) PrepareUVsAndTexCoords(
    CBaseMeshLod lod,
    CMeshVertex vert1,
    CMeshVertex vert2,
    CMeshVertex vert3,
    int[] indices
  )
  {
    return PrepareUVsAndTexCoords(
      lod.VertexColors ?? new FColor[lod.NumVerts],
      vert1,
      vert2,
      vert3,
      lod.ExtraUV.Value,
      indices
    );
  }

  public static (
    VertexColorXTextureX,
    VertexColorXTextureX,
    VertexColorXTextureX
  ) PrepareUVsAndTexCoords(
    FColor[] colors,
    CMeshVertex vert1,
    CMeshVertex vert2,
    CMeshVertex vert3,
    FMeshUVFloat[][] uvs,
    int[] indices
  )
  {
    var (uvs1, uvs2, uvs3) = PrepareUVs(vert1, vert2, vert3, uvs, indices);

    var c1 = new VertexColorXTextureX((Vector4)colors[indices[0]] / 255, uvs1);
    var c2 = new VertexColorXTextureX((Vector4)colors[indices[1]] / 255, uvs2);
    var c3 = new VertexColorXTextureX((Vector4)colors[indices[2]] / 255, uvs3);

    return (c1, c2, c3);
  }

  private static (List<Vector2>, List<Vector2>, List<Vector2>) PrepareUVs(
    CMeshVertex vert1,
    CMeshVertex vert2,
    CMeshVertex vert3,
    FMeshUVFloat[][] uvs,
    int[] indices
  )
  {
    var uvs1 = new List<Vector2>() { (Vector2)vert1.UV };
    var uvs2 = new List<Vector2>() { (Vector2)vert2.UV };
    var uvs3 = new List<Vector2>() { (Vector2)vert3.UV };

    foreach (var uv in uvs)
    {
      uvs1.Add((Vector2)uv[indices[0]]);
      uvs2.Add((Vector2)uv[indices[1]]);
      uvs3.Add((Vector2)uv[indices[2]]);
    }

    return (uvs1, uvs2, uvs3);
  }
}