const std = @import("std");
const formats = @import("formats");
const types = @import("types.zig");
const AssetType = types.AssetType;
const AssetPath = types.AssetPath;
const asset_list = @import("asset_list.zig");
const AssetListEntry = asset_list.AssetListEntry;
const Vector2 = formats.Vector2;
const Vector3 = formats.Vector3;
const za = @import("zalgebra");
const Vec3 = za.Vec3;
const Vec4 = za.Vec4;
const Mat4 = za.Mat4;
const c = @cImport({
    @cInclude("assimp/cimport.h");
    @cInclude("assimp/scene.h");
    @cInclude("assimp/mesh.h");
    @cInclude("assimp/material.h");
    @cInclude("assimp/postprocess.h");

    @cInclude("stb_image.h");

    @cInclude("ispc_texcomp.h");

    @cInclude("spirv-cross/spirv_cross_c.h");
});

const ASSET_MAX_BYTES = 1024 * 1024 * 1024;

const scene_formats = [_][]const u8{
    ".obj",
    ".fbx",
    ".gltf",
    ".glb",
};

pub fn resolveAssetTypeByExtension(path: []const u8) ?AssetType {
    for (scene_formats) |ext| {
        if (std.mem.endsWith(u8, path, ext)) {
            return .Scene;
        }
    }
    if (std.mem.endsWith(u8, path, ".prog")) {
        return .ShaderProgram;
    }
    if (std.mem.endsWith(u8, path, ".png") or std.mem.endsWith(u8, path, ".jpg") or std.mem.endsWith(u8, path, ".exr") or std.mem.endsWith(u8, path, ".dds") or std.mem.endsWith(u8, path, ".tga")) {
        return .Texture;
    }
    return null;
}

const Args = struct {
    dep_file: ?[]const u8 = null,
    input_file: []const u8 = "",
    output_dir: []const u8 = "",
};

// Single producer, multiple consumers
fn JobQueue(comptime JobPayload: type) type {
    return struct {
        const Self = @This();

        pub const JobFn = fn (payload: *JobPayload) void;
        pub const Job = struct {
            payload: JobPayload,
            func: JobFn,
        };

        running: std.atomic.Value(bool) = std.atomic.Value(bool).init(true),

        read: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
        write: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
        buffer: []Job,

        pub fn init(buffer: []Job) JobQueue {
            return JobQueue{
                .buffer = buffer,
            };
        }

        pub fn pushJobs(self: *Self, jobs: []const Job) void {
            var left_to_write: usize = jobs.len;
            while (left_to_write > 0) {
                const write = self.write.load(.unordered);
                if (write >= (self.read.load(.unordered) + self.buffer.len)) {
                    continue;
                }

                const read = self.read.load(.acquire);

                const to_write = @min(self.buffer.len - (write - read), left_to_write);
                for (0..to_write) |i| {
                    self.buffer[(write + i) % self.buffer.len] = jobs[i];
                }

                _ = self.write.fetchAdd(to_write, .release);

                left_to_write -= to_write;
            }
        }

        pub fn takeJob(self: *Self) Job {
            while (true) {
                const read = self.read.load(.acquire);
                if (self.write.load(.acquire) - read > 0) {
                    if (self.read.cmpxchgStrong(read, read + 1, .release, .acquire)) {
                        return self.buffer[read % self.buffer.len];
                    }
                }
            }
        }

        pub fn workerEntry(userdata: *anyopaque) void {
            const self: Self = @ptrCast(userdata);

            while (self.running.load(.acquire)) {
                const job = self.takeJob();

                job.func(job.payload);
            }
        }
    };
}

const ProcessAssetJobPayload = struct {
    allocator: std.mem.Allocator,
    asset_type: AssetType,
    rel_input: []const u8,
    output_dir: std.fs.Dir,
    dep_file: ?[]const u8,
};

const ProcessAssetJobQueue = JobQueue(ProcessAssetJobPayload);

fn parseArgs(allocator: std.mem.Allocator) !Args {
    var args = try std.process.argsWithAllocator(allocator);
    defer args.deinit();

    var result: Args = .{};

    // Skip program
    _ = args.skip();

    var required_args: [2][]const u8 = undefined;
    var required_arg_cursor: usize = 0;

    while (args.next()) |flag| {
        // Flags
        if (std.mem.eql(u8, flag, "-d") or std.mem.eql(u8, flag, "--depfile")) {
            const dep_file = args.next() orelse return error.MissingDepFile;
            result.dep_file = dep_file;
            continue;
        }

        if (required_arg_cursor >= required_args.len) {
            return error.TooManyUnnamedArgs;
        }
        required_args[required_arg_cursor] = flag;
        required_arg_cursor += 1;
    }

    if (required_arg_cursor != required_args.len) {
        return error.MissingRequiredArgs;
    }

    result.input_file = required_args[0];
    result.output_dir = required_args[1];

    return result;
}

pub fn main() !void {
    const allocator = std.heap.c_allocator;

    const args = parseArgs(allocator) catch |err| {
        std.debug.print("{s}\n", .{std.os.argv});
        std.debug.print(
            \\usage: assetc [flags] <input_file> <output_dir>
            \\
            \\flags:
            \\  -d, --depfile           - output a depfile
            \\
            \\error: {}
        , .{err});
        return err;
    };

    const abs_input = args.input_file;
    const output_dir_path = args.output_dir;

    // HACK: build.zig gives us a path like: zig-cache/o/<hash>/assets
    // assetc outputs paths including the "assets/" prefix, so we do an equivalent
    // of `cd ..` to avoid the "assets/assets/" prefix
    const output_dirname = std.fs.path.dirname(output_dir_path) orelse return error.EmptyOutputPath;

    var cwd_buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
    const cwd_path = try std.process.getCwd(&cwd_buf);

    const rel_input = try std.fs.path.relative(allocator, cwd_path, abs_input);
    const rel_output = try std.fs.path.relative(allocator, cwd_path, output_dirname);

    std.debug.print("rel_input: {s}\nrel_output: {s}\n", .{ rel_input, rel_output });

    var output_dir = try std.fs.cwd().makeOpenPath(rel_output, .{});
    defer output_dir.close();

    const asset_type = resolveAssetTypeByExtension(abs_input) orelse return error.UnknownAssetType;

    var buf_asset_list_writer = std.io.bufferedWriter(std.io.getStdOut().writer());
    const asset_list_writer = buf_asset_list_writer.writer();

    var queue = ProcessAssetJobQueue.init(try allocator.alloc(ProcessAssetJobQueue.Job, 1024));

    const num_workers = std.Thread.getCpuCount() - 1;
    const worker_threads = allocator.alloc(std.Thread, num_workers);

    for (0..num_workers) |i| {
        worker_threads[i] = try std.Thread.spawn(.{}, ProcessAssetJobQueue.workerEntry, .{&queue});
    }

    std.log.debug("type: {s}, rel_input: {s}, output_dir: {s}", .{ @tagName(asset_type), rel_input, rel_output });
    queue.pushJobs(&[]ProcessAssetJobQueue.Job{.{
        .payload = .{
            .allocator = allocator,
            .asset_type = asset_type,
            .rel_input = rel_input,
            .output_dir = output_dir,
            .dep_file = args.dep_file,
        },
        .func = processAsset,
    }});

    try buf_asset_list_writer.flush();

    if (args.dep_file) |dep_file_path| {
        const dep_file = try std.fs.cwd().createFile(dep_file_path, .{ .read = true, .truncate = false });
        dep_file.close();
    }
}

fn processAsset(payload: ProcessAssetJobPayload) void {
    switch (payload.asset_type) {
        .Scene => try processScene(payload.allocator, payload.rel_input, payload.output_dir, payload.asset_list_writer),
        .ShaderProgram => try processShaderProgram(payload.allocator, payload.rel_input, payload.output_dir, payload.dep_file, payload.asset_list_writer),
        .Texture => try processTextureFromFile(payload.allocator, payload.rel_input, payload.output_dir, payload.asset_list_writer),
        else => unreachable,
    }
}

fn copyFile(_type: AssetType, input: []const u8, output_dir: std.fs.Dir, asset_list_writer: anytype) !void {
    const asset_path = AssetPath{ .simple = input };

    const asset_list_entry = AssetListEntry{
        .type = _type,
        .src_path = asset_path,
    };

    var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
    const out_path = try asset_list_entry.getOutputPath(&buf);

    try output_dir.makePath(std.fs.path.dirname(out_path) orelse ".");

    try std.fs.Dir.copyFile(std.fs.cwd(), input, output_dir, out_path, .{});
    try asset_list.writeAssetListEntryText(asset_list_writer, asset_list_entry);
}

const AssetOutput = struct {
    file: std.fs.File,
    list_entry: AssetListEntry,
};

fn createOutput(_type: AssetType, asset_path: AssetPath, output_dir: std.fs.Dir, writer: anytype) !AssetOutput {
    const asset_list_entry = AssetListEntry{
        .type = _type,
        .src_path = asset_path,
    };

    var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
    const out_path = try asset_list_entry.getOutputPath(&buf);

    var output_subdir = try output_dir.makeOpenPath(std.fs.path.dirname(out_path) orelse ".", .{});
    defer output_subdir.close();

    try asset_list.writeAssetListEntryText(writer, asset_list_entry);

    const file = try output_subdir.createFile(std.fs.path.basename(out_path), .{});

    return AssetOutput{
        .file = file,
        .list_entry = asset_list_entry,
    };
}

const AI_MATKEY_NAME = "?mat.name";
const AI_MATKEY_SHADING_MODEL = "$mat.shadingm";
const AI_MATKEY_BASE_COLOR = "$clr.base";
const AI_MATKEY_METALLIC_FACTOR = "$mat.metallicFactor";
const AI_MATKEY_ROUGHNESS_FACTOR = "$mat.roughnessFactor";
const AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLICROUGHNESS_TEXTURE = c.aiTextureType_UNKNOWN;

/// This can output either a single mesh (for simple formats like obj)
/// or a scene + a bunch of sub assets (meshes, materials, textures, animations, etc.)
/// It all depends on the source asset.
fn processScene(allocator: std.mem.Allocator, input: []const u8, output_dir: std.fs.Dir, asset_list_writer: anytype) !void {
    const input_z = try std.mem.concatWithSentinel(allocator, u8, &.{input}, 0);
    const input_dir = std.fs.path.dirname(input) orelse "";
    // const config: *c.aiPropertyStore = @as(?*c.aiPropertyStore, @ptrCast(c.aiCreatePropertyStore())) orelse return error.PropertyStore;
    // defer c.aiReleasePropertyStore(config);

    // // Remove point and line meshes
    // c.aiSetImportPropertyInteger(config, c.AI_CONFIG_PP_SBP_REMOVE, c.aiPrimitiveType_POINT | c.aiPrimitiveType_LINE);

    const maybe_scene: ?*const c.aiScene = @ptrCast(c.aiImportFile(
        input_z.ptr,
        @as(c_uint, @intCast(c.aiProcess_CalcTangentSpace | c.aiProcess_Triangulate | c.aiProcess_JoinIdenticalVertices | c.aiProcess_SortByPType | c.aiProcess_GenNormals | c.aiProcess_ImproveCacheLocality)) | c.aiProcess_GenBoundingBoxes,
    ));
    if (maybe_scene == null) {
        std.log.err("assimp import error: {s}\n", .{c.aiGetErrorString()});
        return error.ImportFailed;
    }
    const scene = maybe_scene.?;
    // defer c.aiReleaseImport(scene);

    if (scene.mNumMeshes == 0) return error.NoMeshes;

    const base_asset_path = AssetPath{ .simple = input };

    // Embedded textures
    var texture_outputs = try allocator.alloc(TextureOutput, @intCast(scene.mNumTextures));
    if (scene.mTextures != null) {
        const textures: []*c.aiTexture = @ptrCast(scene.mTextures[0..@intCast(scene.mNumTextures)]);

        for (textures, 0..) |texture, i| {
            if (texture.mHeight != 0) {
                std.log.debug("TODO: support loading raw textures from assimp\n", .{});
                return error.UnsupportedRawTexture;
            }

            var name: []u8 = @alignCast(texture.mFilename.data[0..texture.mFilename.length]);
            if (name.len == 0) {
                name = try std.fmt.allocPrint(allocator, "texture_{}", .{i + 1});
            }

            texture_outputs[i] = .{
                .texture = texture,
                .asset = try createOutput(.Texture, base_asset_path.subPath(name), output_dir, asset_list_writer),
            };
        }
    }

    for (texture_outputs) |*tex_out| {
        defer tex_out.asset.file.close();

        try processTexture(
            allocator,
            tex_out.tex_type,
            @as([*]u8, @ptrCast(tex_out.texture.pcData))[0..@intCast(tex_out.texture.mWidth)],
            tex_out.asset.file,
            &tex_out.has_alpha,
        );
    }

    // Materials
    var material_outputs = try allocator.alloc(formats.Material, @intCast(scene.mNumMaterials));
    if (scene.mMaterials != null) {
        const materials: []*c.aiMaterial = @ptrCast(scene.mMaterials[0..@intCast(scene.mNumMaterials)]);

        for (materials, 0..) |material, i| {
            var mat_output = formats.Material{};

            var base_color: c.aiColor4D = .{};
            if (c.aiGetMaterialColor(material, AI_MATKEY_BASE_COLOR, 0, 0, &base_color) == c.aiReturn_SUCCESS) {
                // TODO: rgba
                mat_output.albedo = Vec4.new(base_color.r, base_color.g, base_color.b, base_color.a);

                if (base_color.a < 1.0) {
                    mat_output.blend_mode = .AlphaMask;
                }
            }

            if (c.aiGetMaterialTextureCount(material, c.aiTextureType_BASE_COLOR) > 0) {
                const mat_texture = try getMaterialTexture(allocator, input_dir, material, c.aiTextureType_BASE_COLOR, 0);
                var has_alpha = false;
                const entry = mat_texture.path.resolveAssetListEntry(texture_outputs, &has_alpha);
                mat_output.albedo_map.id = entry.getAssetId();
                if (has_alpha) {
                    mat_output.blend_mode = .AlphaMask;
                }
            }

            _ = c.aiGetMaterialFloat(material, AI_MATKEY_METALLIC_FACTOR, 0, 0, &mat_output.metallic);
            if (c.aiGetMaterialTextureCount(material, c.aiTextureType_METALNESS) > 0) {
                const mat_texture = try getMaterialTexture(allocator, input_dir, material, c.aiTextureType_METALNESS, 0);
                const entry = mat_texture.path.resolveAssetListEntry(texture_outputs, null);
                mat_output.metallic_map.id = entry.getAssetId();
            }

            _ = c.aiGetMaterialFloat(material, AI_MATKEY_ROUGHNESS_FACTOR, 0, 0, &mat_output.roughness);
            if (c.aiGetMaterialTextureCount(material, c.aiTextureType_DIFFUSE_ROUGHNESS) > 0) {
                const mat_texture = try getMaterialTexture(allocator, input_dir, material, c.aiTextureType_DIFFUSE_ROUGHNESS, 0);
                const entry = mat_texture.path.resolveAssetListEntry(texture_outputs, null);
                mat_output.roughness_map.id = entry.getAssetId();
            }

            if (c.aiGetMaterialTextureCount(material, c.aiTextureType_NORMALS) > 0) {
                const mat_texture = try getMaterialTexture(allocator, input_dir, material, c.aiTextureType_NORMALS, 0);
                const entry = mat_texture.path.resolveAssetListEntry(texture_outputs, null);
                switch (mat_texture.path) {
                    .embedded => |idx| {
                        texture_outputs[idx].tex_type = .Normal;
                    },
                    else => {},
                }
                mat_output.normal_map.id = entry.getAssetId();
            }
            material_outputs[i] = mat_output;
        }
    }

    const meshes: []*c.aiMesh = @ptrCast(scene.mMeshes[0..@intCast(scene.mNumMeshes)]);
    var mesh_outputs = try allocator.alloc(AssetListEntry, meshes.len);
    for (meshes, 0..) |mesh, i| {
        const name = mesh.mName.data[0..mesh.mName.length];

        var output = try createOutput(.Mesh, base_asset_path.subPath(try allocator.dupe(u8, name)), output_dir, asset_list_writer);
        defer output.file.close();

        if (mesh.mMaterialIndex < 0 or @as(usize, @intCast(mesh.mMaterialIndex)) > material_outputs.len) {
            return error.InvalidMaterialIndex;
        }

        mesh_outputs[i] = output.list_entry;

        try processMesh(allocator, scene, material_outputs, mesh, output.file);
    }

    if (scene.mRootNode == null) return;

    var node_to_entity_idx = std.AutoHashMap(*c.aiNode, usize).init(allocator);
    var entities = std.ArrayList(formats.Entity.Data).init(allocator);
    var parents = std.ArrayList(i64).init(allocator);

    // Breadth first traversal
    var nodeq = std.ArrayList(*c.aiNode).init(allocator);
    try nodeq.append(@ptrCast(scene.mRootNode));

    while (nodeq.popOrNull()) |node| {
        if (node.mChildren != null) {
            const children: []*c.aiNode = @ptrCast(node.mChildren[0..@intCast(node.mNumChildren)]);
            for (0..children.len) |i| {
                // Reverse order, because pop taks from end of the list
                const child = children[children.len - i - 1];
                try nodeq.append(child);
            }
        }

        try entities.append(.{});
        const idx = entities.items.len - 1;
        try node_to_entity_idx.put(node, idx);

        const maybe_parent: ?*c.aiNode = @ptrCast(node.mParent);
        if (maybe_parent) |parent| {
            const parent_idx = node_to_entity_idx.get(parent) orelse return error.MissingParentIdx; // this is a bug in our code
            try parents.append(@intCast(parent_idx));
        } else {
            try parents.append(-1);
        }

        const ent = &entities.items[idx];

        var mat = Mat4.fromSlice(@ptrCast(&node.mTransformation));
        mat = mat.transpose();
        const mat_decomp = mat.decompose();
        ent.transform.pos = mat_decomp.t;
        ent.transform.rot = mat_decomp.r;
        ent.transform.scale = mat_decomp.s;

        if (node.mMeshes != null) {
            const mesh_indices = node.mMeshes[0..node.mNumMeshes];
            if (mesh_indices.len == 1) {
                const mesh_entry = mesh_outputs[mesh_indices[0]];

                ent.flags.mesh = true;
                ent.mesh.handle = .{ .id = mesh_entry.getAssetId() };
            } else {
                for (mesh_indices) |mesh_idx| {
                    const mesh_entry = mesh_outputs[@intCast(mesh_idx)];

                    try entities.append(.{});
                    const sub_idx = entities.items.len - 1;
                    try parents.append(@intCast(idx));
                    const sub_ent = &entities.items[sub_idx];

                    sub_ent.flags.mesh = true;

                    sub_ent.mesh = .{
                        .handle = .{ .id = mesh_entry.getAssetId() },
                    };
                }
            }
        }
    }

    const out_scene = formats.Scene{
        .header = .{
            .entity_count = @intCast(entities.items.len),
        },
        .entities = entities.items,
        .parents = parents.items,
    };

    const output = try createOutput(.Scene, base_asset_path.subPath("scene"), output_dir, asset_list_writer);
    defer output.file.close();
    var buf_writer = std.io.bufferedWriter(output.file.writer());
    try formats.writeScene(buf_writer.writer(), out_scene, formats.native_endian);
    try buf_writer.flush();
}

const TextureOutput = struct {
    texture: *c.aiTexture,
    asset: AssetOutput,
    tex_type: TextureType = .Color,
    has_alpha: bool = false,
};

const AssimpTextureRef = union(enum) {
    external: []const u8,
    embedded: usize,

    pub fn fromRelativePath(allocator: std.mem.Allocator, input_dir: []const u8, str: []const u8) !AssimpTextureRef {
        if (str.len == 0) return error.EmptyPath;

        if (str[0] == '*') {
            const idx = try std.fmt.parseInt(usize, str[1..], 10);

            return .{ .embedded = idx };
        }

        const resolved_path = try std.fs.path.resolve(allocator, &.{ input_dir, str });
        defer allocator.free(resolved_path);
        const cwd_relative_path = try std.fs.path.relative(allocator, try std.fs.cwd().realpathAlloc(allocator, "."), resolved_path);

        return .{ .external = cwd_relative_path };
    }

    pub fn resolveAssetListEntry(self: AssimpTextureRef, embedded: []const TextureOutput, out_has_alpha: ?*bool) AssetListEntry {
        switch (self) {
            .embedded => |idx| {
                if (out_has_alpha) |has_alpha| {
                    has_alpha.* = embedded[idx].has_alpha;
                }
                return embedded[idx].asset.list_entry;
            },
            .external => |path| {
                // TODO: resolve relative to current input file
                // TODO: has_alpha
                return AssetListEntry{ .src_path = AssetPath.fromString(path), .type = .Texture };
            },
        }
    }
};

const MaterialTexture = struct {
    path: AssimpTextureRef = .{ .external = "" },
    mapping: c.aiTextureMapping = 0,
    uv_index: c_uint = 0,
    blend: f32 = 0,
    op: c.aiTextureOp = 0,
    map_mode: [3]c.aiTextureMapMode = .{ 0, 0, 0 },
    flags: c_uint = 0,
};
fn getMaterialTexture(allocator: std.mem.Allocator, input_dir: []const u8, material: *c.aiMaterial, _type: c.aiTextureType, index: c_uint) !MaterialTexture {
    var path: c.aiString = undefined;
    var result: MaterialTexture = .{};

    try tryAssimp(c.aiGetMaterialTexture(
        material,
        _type,
        index,
        &path,
        &result.mapping,
        &result.uv_index,
        &result.blend,
        &result.op,
        &result.map_mode,
        &result.flags,
    ));

    const path_str: []u8 = @alignCast(path.data[0..path.length]);
    result.path = try AssimpTextureRef.fromRelativePath(allocator, input_dir, path_str);

    return result;
}

fn processMesh(allocator: std.mem.Allocator, scene: *const c.aiScene, material_outputs: []const formats.Material, mesh: *const c.aiMesh, out_file: std.fs.File) !void {
    _ = scene; // autofix
    if (mesh.mNormals == null) return error.MissingNormals;
    if (mesh.mTangents == null) return error.MissingTangents;
    if (mesh.mTextureCoords[0] == null) return error.MissingUVs;
    if (mesh.mNumUVComponents[0] != 2) return error.WrongUVComponents;

    var vertices = try allocator.alloc(Vector3, @intCast(mesh.mNumVertices));
    var normals = try allocator.alloc(Vector3, @intCast(mesh.mNumVertices));
    var tangents = try allocator.alloc(Vector3, @intCast(mesh.mNumVertices));
    var uvs = try allocator.alloc(Vector2, @intCast(mesh.mNumVertices));

    var indices = try allocator.alloc(formats.Index, @intCast(mesh.mNumFaces * 3)); // triangles

    for (0..mesh.mNumVertices) |i| {
        vertices[i] = .{
            .x = mesh.mVertices[i].x,
            .y = mesh.mVertices[i].y,
            .z = mesh.mVertices[i].z,
        };
        normals[i] = .{
            .x = mesh.mNormals[i].x,
            .y = mesh.mNormals[i].y,
            .z = mesh.mNormals[i].z,
        };
        tangents[i] = .{
            .x = mesh.mTangents[i].x,
            .y = mesh.mTangents[i].y,
            .z = mesh.mTangents[i].z,
        };
        uvs[i] = .{
            .x = mesh.mTextureCoords[0][i].x,
            .y = mesh.mTextureCoords[0][i].y,
        };
    }

    for (0..mesh.mNumFaces) |i| {
        if (mesh.mFaces[i].mNumIndices != 3) continue;
        for (0..3) |j| {
            const index = mesh.mFaces[i].mIndices[j];
            if (index > std.math.maxInt(formats.Index)) {
                std.log.err("indices out of range for index format: {}\n", .{index});
                return error.TimeToIncreaseIndexSize;
            }
            indices[i * 3 + j] = @intCast(index);
        }
    }

    const material = material_outputs[@intCast(mesh.mMaterialIndex)];

    const out_mesh = formats.Mesh{
        .aabb = .{
            .min = formats.Vector3{
                .x = mesh.mAABB.mMin.x,
                .y = mesh.mAABB.mMin.y,
                .z = mesh.mAABB.mMin.z,
            },
            .max = formats.Vector3{
                .x = mesh.mAABB.mMax.x,
                .y = mesh.mAABB.mMax.y,
                .z = mesh.mAABB.mMax.z,
            },
        },
        .vertices = vertices,
        .normals = normals,
        .tangents = tangents,
        .uvs = uvs,
        .indices = indices,
        .material = material,
    };

    var buf_writer = std.io.bufferedWriter(out_file.writer());
    try formats.writeMesh(
        buf_writer.writer(),
        out_mesh,
        formats.native_endian, // TODO: use target endiannes
    );
    try buf_writer.flush();
}

const DEPFILE_MAX_BYTES = 1024 * 16;
fn readFileContents(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
    return std.fs.cwd().readFileAlloc(allocator, path, DEPFILE_MAX_BYTES) catch |err| switch (err) {
        error.FileNotFound => {
            return allocator.alloc(u8, 0);
        },
        else => |e| {
            return e;
        },
    };
}

// Returns spirv binary source
// Caller owns memory
fn processShader(allocator: std.mem.Allocator, flags: []const []const u8, input: []const u8, maybe_dep_file: ?[]const u8) ![]u8 {
    const old_depfile_contents = if (maybe_dep_file) |dep| try readFileContents(allocator, dep) else try allocator.alloc(u8, 0);
    defer allocator.free(old_depfile_contents);

    // TODO: make sure output is stdout
    const result = try std.process.Child.run(.{
        .allocator = allocator,
        .argv = try std.mem.concat(allocator, []const u8, &.{
            &.{ "glslc", "--target-env=vulkan1.3", "-std=460core", "-g", "-o", "-" },
            if (maybe_dep_file) |dep| &.{ "-MD", "-MF", dep } else &.{},
            flags,
            &.{input},
        }),
    });
    defer allocator.free(result.stderr);
    errdefer allocator.free(result.stdout);

    switch (result.term) {
        .Exited => |status| {
            if (status != 0) {
                std.log.debug("Shader compilation failed with status {}:\n{s}\n", .{ result.term.Exited, result.stderr });
                return error.ShaderCompileError;
            }
        },
        else => {
            return error.UnknownShaderCompileError;
        },
    }

    // TODO: figure out a better way to handle depfile
    if (maybe_dep_file) |dep_file| {
        const file = try std.fs.cwd().openFile(dep_file, .{ .mode = .read_write });
        defer file.close();
        try file.seekFromEnd(0);
        try file.writeAll(old_depfile_contents);
    }

    // {
    //     var spvc_context: c.spvc_context = null;
    //     _ = c.spvc_context_create(&spvc_context);
    //     defer c.spvc_context_destroy(spvc_context);

    //     var ir: c.spvc_parsed_ir = null;
    //     // c.spvc_context_parse_spirv(spvc_context, spirv: [*c]const c.SpvId, word_count: usize, &ir);

    //     var compiler_glsl: c.spvc_compiler = null;
    //     c.spvc_context_create_compiler(spvc_context, c.SPVC_BACKEND_GLSL, ir, c.SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler_glsl);

    //     var resources: c.spvc_resources = null;
    //     c.spvc_compiler_create_shader_resources(compiler_glsl, &resources);
    // }

    return result.stdout;
}

fn processShaderProgram(allocator: std.mem.Allocator, input: []const u8, output_dir: std.fs.Dir, dep_file: ?[]const u8, asset_list_writer: anytype) !void {
    const input_dir = std.fs.path.dirname(input).?;

    // Recreate file in case it's not empty
    if (dep_file) |dep| {
        const file = try std.fs.cwd().createFile(dep, .{});
        defer file.close();
    }

    var file_contents: []u8 = undefined;
    {
        const input_file = try std.fs.cwd().openFile(input, .{});
        defer input_file.close();
        file_contents = try input_file.readToEndAlloc(allocator, ASSET_MAX_BYTES);
    }
    defer allocator.free(file_contents);

    // const InputShaderStage = struct {
    //     source: []const u8,
    //     entry: []const u8,
    // };

    const InputShaderProgram = struct {
        vertex: ?[]const u8,
        fragment: ?[]const u8,
        compute: ?[]const u8,
    };
    const program = try std.json.parseFromSlice(InputShaderProgram, allocator, file_contents, .{});
    defer program.deinit();

    var result: formats.ShaderProgram = undefined;

    if (program.value.vertex != null and program.value.fragment != null) {
        result = .{ .graphics = undefined };
        // TODO: remove duplication
        {
            const stage = program.value.vertex.?;
            const shader_source_path = try std.fs.path.resolve(allocator, &.{ input_dir, stage });
            const relative_path = try std.fs.path.relative(allocator, try std.fs.cwd().realpathAlloc(allocator, "."), shader_source_path);

            const shader_source = try processShader(allocator, &.{ "-DVERTEX_SHADER=1", "-fshader-stage=vert" }, relative_path, dep_file);
            result.graphics.vertex.source = shader_source;
        }
        {
            const stage = program.value.fragment.?;
            const shader_source_path = try std.fs.path.resolve(allocator, &.{ input_dir, stage });
            const relative_path = try std.fs.path.relative(allocator, try std.fs.cwd().realpathAlloc(allocator, "."), shader_source_path);

            const shader_source = try processShader(allocator, &.{ "-DFRAGMENT_SHADER=1", "-fshader-stage=frag" }, relative_path, dep_file);
            result.graphics.fragment.source = shader_source;
        }
    } else if (program.value.compute != null) {
        result = .{ .compute = undefined };

        const stage = program.value.compute.?;
        const shader_source_path = try std.fs.path.resolve(allocator, &.{ input_dir, stage });
        const relative_path = try std.fs.path.relative(allocator, try std.fs.cwd().realpathAlloc(allocator, "."), shader_source_path);

        const shader_source = try processShader(allocator, &.{ "-DCOMPUTE_SHADER=1", "-fshader-stage=compute" }, relative_path, dep_file);
        result.compute.compute.source = shader_source;
    } else {
        std.log.err("Provide vertex and fragment shaders for a graphics pipeline or a compute shader for a compute pipeline\n", .{});
        return error.InvalidPipelines;
    }

    const output = try createOutput(.ShaderProgram, AssetPath{ .simple = input }, output_dir, asset_list_writer);
    defer output.file.close();

    var serializer = formats.Serializer{
        .stream = std.io.StreamSource{ .file = output.file },
        .write = true,
        // TODO: figure out target endianness
        .endian = formats.native_endian,
    };

    try result.serialize(&serializer);
}

const MipLevel = struct {
    width: usize,
    height: usize,
    data: []u8,
    out_data: []const u8 = &.{},
};

fn processTextureFromFile(allocator: std.mem.Allocator, input: []const u8, output_dir: std.fs.Dir, asset_list_writer: anytype) !void {
    const output = try createOutput(.Texture, AssetPath{ .simple = input }, output_dir, asset_list_writer);
    defer output.file.close();

    const contents = try std.fs.cwd().readFileAlloc(allocator, input, ASSET_MAX_BYTES);
    const texture_type = guessTextureTypeFromName(input);

    var has_alpha = false;
    try processTexture(allocator, texture_type, contents, output.file, &has_alpha);
}

/// Using naming conventions
fn guessTextureTypeFromName(name: []const u8) TextureType {
    const stem = std.fs.path.stem(name);
    var buf: [std.fs.MAX_NAME_BYTES]u8 = undefined;
    const lower_stem = std.ascii.lowerString(&buf, stem);
    const sub_ext = std.fs.path.extension(lower_stem);
    if (std.mem.eql(u8, sub_ext, ".norm")) {
        return .Normal;
    }
    if (std.mem.endsWith(u8, lower_stem, "normal")) {
        return .Normal;
    }
    if (std.mem.endsWith(u8, lower_stem, "metallicroughness")) {
        return .MetallicRoughness;
    }

    return .Color;
}

const TextureType = enum {
    Color,
    Normal,
    MetallicRoughness,
    HDR,
};

fn processTexture(allocator: std.mem.Allocator, texture_type: TextureType, contents: []const u8, out_file: std.fs.File, out_has_alpha: *bool) !void {
    var width_int: c_int = 0;
    var height_int: c_int = 0;
    var comps: c_int = 0;

    c.stbi_set_flip_vertically_on_load(1);
    const rgba_data_c = c.stbi_load_from_memory(contents.ptr, @intCast(contents.len), &width_int, &height_int, &comps, 4);
    if (rgba_data_c == null) {
        return error.ImageLoadError;
    }
    defer c.stbi_image_free(rgba_data_c);

    var format = formats.Texture.Format.bc7;

    // TODO: bc4
    if (comps == 1) {}
    if (texture_type == .Normal or comps == 2) {
        format = .bc5;
    }

    const width: usize = @intCast(width_int);
    const height: usize = @intCast(height_int);

    const rgba_data = rgba_data_c[0 .. width * height * 4];

    if (comps == 4) {
        var i: usize = 3;
        while (i < rgba_data.len) : (i += 4) {
            if (rgba_data[i] < 255) {
                out_has_alpha.* = true;
                break;
            }
        }
    }

    var padded_width: usize = width;
    var padded_height: usize = height;
    var rgba_data_padded = rgba_data;
    if (width % 4 != 0 or height % 4 != 0 or width < 4 or height < 4) {
        padded_width = @max(width + width % 4, 4);
        padded_height = @max(height + height % 4, 4);

        rgba_data_padded = try allocator.alloc(u8, padded_width * padded_height * 4);

        var dst_surf = c.rgba_surface{
            .width = @intCast(padded_width),
            .height = @intCast(padded_height),
            .stride = @intCast(padded_width * 4),
            .ptr = rgba_data_padded.ptr,
        };
        var src_surf = c.rgba_surface{
            .width = @intCast(width),
            .height = @intCast(height),
            .stride = @intCast(width * 4),
            .ptr = rgba_data.ptr,
        };
        c.ReplicateBorders(&dst_surf, &src_surf, 0, 0, 32);
    }

    // if (comps == 4) {
    //     premultiplyAlpha(rgba_data);
    // }

    const data_channels: usize = if (format == .bc5) 2 else 4;
    const data = if (data_channels < 4) dropChannels(rgba_data_padded, data_channels) else rgba_data_padded;

    const mip_levels_to_gen = 1 + @as(
        u32,
        @intFromFloat(@log2(@as(f32, @floatFromInt(@max(width, height))))),
    );
    var actual_mip_count: usize = 1;

    var mip_pyramid = std.ArrayList(MipLevel).init(allocator);
    try mip_pyramid.append(MipLevel{
        .data = data,
        .width = padded_width,
        .height = padded_height,
    });

    for (1..mip_levels_to_gen) |mip_level| {
        const divisor = std.math.powi(usize, 2, mip_level) catch unreachable;
        const mip_width = padded_width / divisor;
        const mip_height = padded_height / divisor;

        if (mip_width % 4 != 0 or mip_height % 4 != 0) {
            break;
        }

        try mip_pyramid.append(
            MipLevel{
                .width = mip_width,
                .height = mip_height,
                .data = try allocator.alloc(u8, mip_width * mip_height * data_channels),
            },
        );
        actual_mip_count += 1;
    }
    std.log.debug("mip count {}\n", .{actual_mip_count});

    for (0..actual_mip_count) |mip_level| {
        const mip_data = &mip_pyramid.items[mip_level];
        if (mip_level > 0) {
            switch (data_channels) {
                2 => downsampleRGImage2X(&mip_pyramid.items[mip_level - 1], mip_data),
                4 => downsampleRGBAImage2X(&mip_pyramid.items[mip_level - 1], mip_data),
                else => unreachable,
            }
        }

        std.log.debug("mip size {}x{}", .{ mip_data.width, mip_data.height });
        mip_data.out_data = try compressBlocksAlloc(allocator, mip_data.data, data_channels, format, @intCast(comps), mip_data.width, mip_data.height);
    }

    const out_data = try allocator.alloc([]const u8, actual_mip_count);
    for (0..actual_mip_count) |mip_level| {
        out_data[mip_level] = mip_pyramid.items[mip_level].out_data;
    }

    const texture = formats.Texture{
        .header = .{
            .format = format,
            .width = @intCast(width),
            .height = @intCast(height),
            .padded_width = @intCast(padded_width),
            .padded_height = @intCast(padded_height),
            .mip_count = @intCast(actual_mip_count),
        },
        .data = out_data,
    };

    var buf_writer = std.io.bufferedWriter(out_file.writer());

    try formats.writeTexture(buf_writer.writer(), texture, formats.native_endian);
    try buf_writer.flush();
}

fn compressBlocksAlloc(
    allocator: std.mem.Allocator,
    pixels: []u8,
    components: usize, // 2 for normal maps, 4 for everything else
    format: formats.Texture.Format,
    original_components: usize, // how many components in original image. Does not match actual components
    width: usize,
    height: usize,
) ![]u8 {
    std.debug.assert(width % 4 == 0);
    std.debug.assert(height % 4 == 0);

    const blocks_x = width / 4;
    const blocks_y = height / 4;

    const rgba_surf = c.rgba_surface{
        .width = @intCast(width),
        .height = @intCast(height),
        .stride = @intCast(width * components),
        .ptr = pixels.ptr,
    };

    const output = try allocator.alloc(u8, blocks_x * blocks_y * 16);
    switch (format) {
        .bc7 => {
            var settings: c.bc7_enc_settings = .{};
            if (original_components == 4) {
                c.GetProfile_alpha_ultrafast(&settings);
            } else {
                c.GetProfile_ultrafast(&settings);
            }
            c.CompressBlocksBC7(&rgba_surf, output.ptr, &settings);
        },
        .bc5 => {
            std.debug.assert(components == 2);
            c.CompressBlocksBC5(&rgba_surf, output.ptr);
        },
        .bc6 => {
            return error.NotImplementedYet;
        },
    }

    return output;
}

fn dropChannels(rgba_data: []u8, channel_count: usize) []u8 {
    for (0..rgba_data.len / 4) |i| {
        for (0..channel_count) |j| {
            rgba_data[i * 2 + j] = rgba_data[i * 4 + j];
        }
    }

    return rgba_data[0 .. (rgba_data.len / 4) * channel_count];
}

const gamma = 2.2;
const srgb_to_linear: [256]u8 = blk: {
    @setEvalBranchQuota(10000);
    var result: [256]u8 = undefined;
    for (0..256) |i| {
        var f: f32 = @floatFromInt(i);
        f /= 255.0;
        result[i] = @intFromFloat(std.math.pow(f32, f, gamma) * 255.0);
    }
    break :blk result;
};

fn convertSrgb(img: []u8) void {
    @setRuntimeSafety(false);

    for (0..img.len / 4) |i| {
        const pixel = img[i * 4 .. i * 4 + 4];

        pixel[0] = srgb_to_linear[pixel[0]];
        pixel[1] = srgb_to_linear[pixel[1]];
        pixel[2] = srgb_to_linear[pixel[2]];
    }
}

fn premultiplyAlpha(img: []u8) void {
    for (0..img.len / 4) |i| {
        const pixel = img[i * 4 .. i * 4 + 4];

        const r = @as(f32, @floatFromInt(pixel[0])) / 255.0;
        const g = @as(f32, @floatFromInt(pixel[1])) / 255.0;
        const b = @as(f32, @floatFromInt(pixel[2])) / 255.0;
        const a = @as(f32, @floatFromInt(pixel[3])) / 255.0;

        pixel[0] = @intFromFloat(r * a * 255.0);
        pixel[1] = @intFromFloat(g * a * 255.0);
        pixel[2] = @intFromFloat(b * a * 255.0);
    }
}

inline fn vecPow(x: @Vector(4, f32), y: f32) @Vector(4, f32) {
    return @exp(@log(x) * @as(@Vector(4, f32), @splat(y)));
}

fn downsampleRGImage2X(src: *const MipLevel, dst: *const MipLevel) void {
    const srcStride = src.width * 2;
    const dstStride = dst.width * 2;
    for (0..dst.height) |y| {
        for (0..dst.width) |x| {
            const x0 = x * 2;
            const y0 = y * 2;
            var result = @Vector(2, f32){ 0, 0 };

            for (0..2) |y1| {
                for (0..2) |x1| {
                    const srcX = x0 + x1;
                    const srcY = y0 + y1;

                    result += loadColorVec2(src.data[srcY * srcStride + srcX * 2 ..]);
                }
            }

            result /= @splat(4);
            storeColorVec2(dst.data[y * dstStride + x * 2 ..], result);
        }
    }
}

fn downsampleRGBAImage2X(src: *const MipLevel, dst: *const MipLevel) void {
    const srcStride = src.width * 4;
    const dstStride = dst.width * 4;
    for (0..dst.height) |y| {
        for (0..dst.width) |x| {
            const x0 = x * 2;
            const y0 = y * 2;
            var result = @Vector(4, f32){ 0, 0, 0, 0 };

            for (0..2) |y1| {
                for (0..2) |x1| {
                    const srcX = x0 + x1;
                    const srcY = y0 + y1;

                    result += loadColorVec4(src.data[srcY * srcStride + srcX * 4 ..]);
                }
            }

            result /= @splat(4);
            storeColorVec4(dst.data[y * dstStride + x * 4 ..], result);
        }
    }
}

inline fn loadColorVec2(pixel: []const u8) @Vector(2, f32) {
    @setRuntimeSafety(false);
    std.debug.assert(pixel.len >= 2);

    return @Vector(2, f32){
        @as(f32, @floatFromInt(pixel[0])),
        @as(f32, @floatFromInt(pixel[1])),
    } / @as(@Vector(2, f32), @splat(255.0));
}

inline fn storeColorVec2(pixel: []u8, vec: @Vector(2, f32)) void {
    @setRuntimeSafety(false);
    std.debug.assert(pixel.len >= 2);

    const out = vec * @as(@Vector(2, f32), @splat(255.0));

    pixel[0] = @intFromFloat(out[0]);
    pixel[1] = @intFromFloat(out[1]);
}

inline fn loadColorVec4(pixel: []const u8) @Vector(4, f32) {
    @setRuntimeSafety(false);
    std.debug.assert(pixel.len >= 4);

    return @Vector(4, f32){
        @as(f32, @floatFromInt(pixel[0])),
        @as(f32, @floatFromInt(pixel[1])),
        @as(f32, @floatFromInt(pixel[2])),
        @as(f32, @floatFromInt(pixel[3])),
    } / @as(@Vector(4, f32), @splat(255.0));
}

inline fn storeColorVec4(pixel: []u8, vec: @Vector(4, f32)) void {
    @setRuntimeSafety(false);
    std.debug.assert(pixel.len >= 4);

    const out = vec * @as(@Vector(4, f32), @splat(255.0));

    pixel[0] = @intFromFloat(out[0]);
    pixel[1] = @intFromFloat(out[1]);
    pixel[2] = @intFromFloat(out[2]);
    pixel[3] = @intFromFloat(out[3]);
}

fn tryAssimp(code: c.aiReturn) !void {
    switch (code) {
        c.aiReturn_SUCCESS => {},
        c.aiReturn_FAILURE => {
            std.log.err("getMaterialTexture: {s}\n", .{c.aiGetErrorString()});
            return error.AssimpError;
        },
        c.aiReturn_OUTOFMEMORY => {
            return error.OutOfMemory;
        },
        else => unreachable,
    }
}