using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using NubLang.Tokenization;
using NubLang.TypeChecking.Node;

namespace NubLang.Generation.QBE;

public class QBEGenerator
{
    private readonly TypedSyntaxTree _syntaxTree;
    private readonly TypedDefinitionTable _definitionTable;
    private readonly QBEWriter _writer;

    private readonly List<CStringLiteral> _cStringLiterals = [];
    private readonly List<StringLiteral> _stringLiterals = [];
    private readonly Stack<string> _breakLabels = [];
    private readonly Stack<string> _continueLabels = [];
    private readonly Stack<Scope> _scopes = [];
    private int _tmpIndex;
    private int _labelIndex;
    private int _cStringLiteralIndex;
    private int _stringLiteralIndex;
    private bool _codeIsReachable = true;

    private Scope Scope => _scopes.Peek();

    public QBEGenerator(TypedSyntaxTree syntaxTree, TypedDefinitionTable definitionTable)
    {
        _syntaxTree = syntaxTree;
        _definitionTable = definitionTable;
        _writer = new QBEWriter();
    }

    public string Emit()
    {
        _cStringLiterals.Clear();
        _stringLiterals.Clear();
        _breakLabels.Clear();
        _continueLabels.Clear();
        _scopes.Clear();
        _tmpIndex = 0;
        _labelIndex = 0;
        _cStringLiteralIndex = 0;
        _stringLiteralIndex = 0;
        _codeIsReachable = true;

        foreach (var structDef in _definitionTable.GetStructs())
        {
            EmitStructTypeDefinition(structDef);
            _writer.NewLine();
        }

        foreach (var structDef in _syntaxTree.Definitions.OfType<StructNode>())
        {
            EmitStructDefinition(structDef);
            _writer.NewLine();
        }

        foreach (var funcDef in _syntaxTree.Definitions.OfType<LocalFuncNode>())
        {
            EmitLocalFuncDefinition(funcDef);
            _writer.NewLine();
        }

        foreach (var structDef in _syntaxTree.Definitions.OfType<StructNode>().Where(x => x.InterfaceImplementations.Count > 0))
        {
            _writer.Write($"data {StructVtableName(structDef.Name)} = {{ ");

            foreach (var interfaceImplementation in structDef.InterfaceImplementations)
            {
                var interfaceDef = _definitionTable.LookupInterface(interfaceImplementation.Name);
                foreach (var func in interfaceDef.Functions)
                {
                    _writer.Write($"l {StructFuncName(structDef.Name, func.Name)}, ");
                }
            }

            _writer.WriteLine("}");
        }

        foreach (var cStringLiteral in _cStringLiterals)
        {
            _writer.WriteLine($"data {cStringLiteral.Name} = {{ b \"{cStringLiteral.Value}\", b 0 }}");
        }

        foreach (var stringLiteral in _stringLiterals)
        {
            var bytes = Encoding.UTF8.GetBytes(stringLiteral.Value).Select(b => $"b {b}");
            _writer.WriteLine($"data {stringLiteral.Name} = {{ l {stringLiteral.Value.Length}, {string.Join(", ", bytes)} }}");
        }

        return _writer.ToString();
    }

    private static string QBEAssign(TypeNode type)
    {
        if (type.IsSimpleType(out var simpleType, out _))
        {
            return simpleType.StorageSize switch
            {
                StorageSize.I8 or StorageSize.U8 or StorageSize.I16 or StorageSize.U16 or StorageSize.I32 or StorageSize.U32 => "=w",
                StorageSize.I64 or StorageSize.U64 => "=l",
                StorageSize.F32 => "=s",
                StorageSize.F64 => "=d",
                _ => throw new ArgumentOutOfRangeException(nameof(simpleType.StorageSize))
            };
        }

        return "=l";
    }

    private void EmitStore(TypeNode type, string value, string destination)
    {
        string store;

        if (type.IsSimpleType(out var simpleType, out _))
        {
            store = simpleType.StorageSize switch
            {
                StorageSize.I8 or StorageSize.U8 => "storeb",
                StorageSize.I16 or StorageSize.U16 => "storeh",
                StorageSize.I32 or StorageSize.U32 => "storew",
                StorageSize.I64 or StorageSize.U64 => "storel",
                StorageSize.F32 => "stores",
                StorageSize.F64 => "stored",
                _ => throw new ArgumentOutOfRangeException(nameof(simpleType.StorageSize))
            };
        }
        else
        {
            store = "storel";
        }

        _writer.Indented($"{store} {value}, {destination}");
    }

    private Val EmitLoad(TypeNode type, string from)
    {
        string load;

        if (type.IsSimpleType(out var simpleType, out _))
        {
            load = simpleType.StorageSize switch
            {
                StorageSize.I64 or StorageSize.U64 => "loadl",
                StorageSize.I32 or StorageSize.U32 => "loadw",
                StorageSize.I16 => "loadsh",
                StorageSize.I8 => "loadsb",
                StorageSize.U16 => "loaduh",
                StorageSize.U8 => "loadub",
                StorageSize.F64 => "loadd",
                StorageSize.F32 => "loads",
                _ => throw new ArgumentOutOfRangeException(nameof(simpleType.StorageSize))
            };
        }
        else
        {
            load = "loadl";
        }

        var into = TmpName();

        _writer.Indented($"{into} {QBEAssign(type)} {load} {from}");

        return new Val(into, type, ValKind.Direct);
    }

    private void EmitMemcpy(string source, string destination, string length)
    {
        _writer.Indented($"call $nub_memcpy(l {source}, l {destination}, l {length})");
    }

    private string EmitArraySizeInBytes(ArrayTypeNode type, string array)
    {
        var size = TmpName();
        _writer.Indented($"{size} =l loadl {array}");
        _writer.Indented($"{size} =l mul {size}, {SizeOf(type.ElementType)}");
        _writer.Indented($"{size} =l add {size}, 8");
        return size;
    }

    private string EmitCStringSizeInBytes(string cstring)
    {
        var size = TmpName();
        _writer.Indented($"{size} =l call $nub_cstring_length(l {cstring})");
        _writer.Indented($"{size} =l add {size}, 1");
        return size;
    }

    private string EmitStringSizeInBytes(string nubstring)
    {
        var size = TmpName();
        _writer.Indented($"{size} =l loadl {nubstring}");
        _writer.Indented($"{size} =l add {size}, 8");
        return size;
    }

    private bool EmitTryMoveInto(ExpressionNode source, string destinationPointer)
    {
        switch (source)
        {
            case ArrayInitializerNode arrayInitializer:
            {
                EmitStore(source.Type, EmitUnwrap(EmitArrayInitializer(arrayInitializer)), destinationPointer);
                return true;
            }
            case StructInitializerNode structInitializer:
            {
                EmitStructInitializer(structInitializer, destinationPointer);
                return true;
            }
            case InterfaceInitializerNode interfaceInitializer:
            {
                EmitInterfaceInitializer(interfaceInitializer, destinationPointer);
                return true;
            }
            case LiteralNode { Kind: LiteralKind.String } literal:
            {
                EmitStore(source.Type, EmitUnwrap(EmitLiteral(literal)), destinationPointer);
                return true;
            }
        }

        return false;
    }

    private void EmitCopyIntoOrInitialize(ExpressionNode source, string destinationPointer)
    {
        // If the source is a value which is not used yet such as an array/struct initializer or literal, we can skip copying
        if (EmitTryMoveInto(source, destinationPointer))
        {
            return;
        }

        var value = EmitUnwrap(EmitExpression(source));

        if (source.Type.IsSimpleType(out var simpleType, out var complexType))
        {
            EmitStore(simpleType, value, destinationPointer);
        }
        else
        {
            if (complexType is StructTypeNode or InterfaceTypeNode)
            {
                EmitMemcpy(value, destinationPointer, SizeOf(complexType).ToString());
            }
            else
            {
                var size = complexType switch
                {
                    ArrayTypeNode arrayType => EmitArraySizeInBytes(arrayType, value),
                    CStringTypeNode => EmitCStringSizeInBytes(value),
                    StringTypeNode => EmitStringSizeInBytes(value),
                    _ => throw new ArgumentOutOfRangeException(nameof(source.Type))
                };

                var buffer = TmpName();
                _writer.Indented($"{buffer} =l alloc8 {size}");
                EmitMemcpy(value, buffer, size);
                EmitStore(complexType, buffer, destinationPointer);
            }
        }
    }

    private bool EmitTryCreateWithoutCopy(ExpressionNode source, [NotNullWhen(true)] out string? destination)
    {
        switch (source)
        {
            case ArrayInitializerNode:
            case StructInitializerNode:
            case InterfaceInitializerNode:
            case LiteralNode { Kind: LiteralKind.String }:
            {
                destination = EmitUnwrap(EmitExpression(source));
                return true;
            }
        }

        destination = null;
        return false;
    }

    private string EmitCreateCopyOrInitialize(ExpressionNode source)
    {
        // If the source is a value which is not used yet such as an array/struct/interface initializer or literal, we can skip copying
        if (EmitTryCreateWithoutCopy(source, out var uncopiedValue))
        {
            return uncopiedValue;
        }

        var value = EmitUnwrap(EmitExpression(source));

        if (source.Type.IsSimpleType(out _, out var complexType))
        {
            // Simple types are passed in registers and are therefore always copied
            return value;
        }

        var size = complexType switch
        {
            ArrayTypeNode arrayType => EmitArraySizeInBytes(arrayType, value),
            CStringTypeNode => EmitCStringSizeInBytes(value),
            StringTypeNode => EmitStringSizeInBytes(value),
            InterfaceTypeNode interfaceType => SizeOf(interfaceType).ToString(),
            StructTypeNode structType => SizeOf(structType).ToString(),
            _ => throw new ArgumentOutOfRangeException(nameof(source.Type))
        };

        var destination = TmpName();
        _writer.Indented($"{destination} =l alloc8 {size}");
        EmitMemcpy(value, destination, size);
        return destination;
    }

    // Utility to create QBE type names for function parameters and return types
    private string FuncQBETypeName(TypeNode type)
    {
        if (type.IsSimpleType(out var simpleType, out var complexType))
        {
            return simpleType.StorageSize switch
            {
                StorageSize.I64 or StorageSize.U64 => "l",
                StorageSize.I32 or StorageSize.U32 => "w",
                StorageSize.I16 => "sh",
                StorageSize.I8 => "sb",
                StorageSize.U16 => "uh",
                StorageSize.U8 => "ub",
                StorageSize.F64 => "d",
                StorageSize.F32 => "s",
                _ => throw new ArgumentOutOfRangeException()
            };
        }

        if (complexType is StructTypeNode structType)
        {
            return StructTypeName(structType.Name);
        }

        return "l";
    }

    private void EmitLocalFuncDefinition(LocalFuncNode funcDef)
    {
        _labelIndex = 0;
        _tmpIndex = 0;

        _writer.Write("export function ");

        if (funcDef.Signature.ReturnType is not VoidTypeNode)
        {
            _writer.Write(FuncQBETypeName(funcDef.Signature.ReturnType) + ' ');
        }

        _writer.Write(LocalFuncName(funcDef));

        _writer.Write("(");
        foreach (var parameter in funcDef.Signature.Parameters)
        {
            _writer.Write(FuncQBETypeName(parameter.Type) + $" %{parameter.Name}");
        }

        _writer.WriteLine(") {");
        _writer.WriteLine("@start");

        var scope = new Scope();

        foreach (var parameter in funcDef.Signature.Parameters)
        {
            scope.Declare(parameter.Name, new Val("%" + parameter.Name, parameter.Type, ValKind.Direct));
        }

        EmitBlock(funcDef.Body, scope);

        // Implicit return for void functions if no explicit return has been set
        if (funcDef.Signature.ReturnType is VoidTypeNode && funcDef.Body.Statements is [.., not ReturnNode])
        {
            _writer.Indented("ret");
        }

        _writer.WriteLine("}");
    }

    private void EmitStructDefinition(StructNode structDef)
    {
        for (var i = 0; i < structDef.Functions.Count; i++)
        {
            var function = structDef.Functions[i];
            _labelIndex = 0;
            _tmpIndex = 0;

            _writer.Write("export function ");

            if (function.Signature.ReturnType is not VoidTypeNode)
            {
                _writer.Write(FuncQBETypeName(function.Signature.ReturnType) + ' ');
            }

            _writer.Write(StructFuncName(structDef.Name, function.Name));

            _writer.Write("(l %this, ");
            foreach (var parameter in function.Signature.Parameters)
            {
                _writer.Write(FuncQBETypeName(parameter.Type) + $" %{parameter.Name}, ");
            }

            _writer.WriteLine(") {");
            _writer.WriteLine("@start");

            var scope = new Scope();

            scope.Declare("this", new Val("%this", structDef.Type, ValKind.Direct));
            foreach (var parameter in function.Signature.Parameters)
            {
                scope.Declare(parameter.Name, new Val("%" + parameter.Name, parameter.Type, ValKind.Direct));
            }

            EmitBlock(function.Body, scope);

            // Implicit return for void functions if no explicit return has been set
            if (function.Signature.ReturnType is VoidTypeNode && function.Body.Statements is [.., not ReturnNode])
            {
                _writer.Indented("ret");
            }

            _writer.WriteLine("}");

            if (i != structDef.Functions.Count - 1)
            {
                _writer.NewLine();
            }
        }
    }

    private void EmitStructTypeDefinition(StructNode structDef)
    {
        _writer.WriteLine($"type {StructTypeName(structDef.Name)} = {{ ");

        var types = new Dictionary<string, string>();

        foreach (var field in structDef.Fields)
        {
            types.Add(field.Name, StructDefQBEType(field));
        }

        var longest = types.Values.Max(x => x.Length);
        foreach (var (name, type) in types)
        {
            var padding = longest - type.Length;
            _writer.Indented($"{type},{new string(' ', padding)} # {name}");
        }

        _writer.WriteLine("}");
        return;

        string StructDefQBEType(StructFieldNode field)
        {
            if (field.Type.IsSimpleType(out var simpleType, out var complexType))
            {
                return simpleType.StorageSize switch
                {
                    StorageSize.I64 or StorageSize.U64 => "l",
                    StorageSize.I32 or StorageSize.U32 => "w",
                    StorageSize.I16 or StorageSize.U16 => "h",
                    StorageSize.I8 or StorageSize.U8 => "b",
                    StorageSize.F64 => "d",
                    StorageSize.F32 => "s",
                    _ => throw new ArgumentOutOfRangeException()
                };
            }

            if (complexType is StructTypeNode structType)
            {
                return StructTypeName(structType.Name);
            }

            return "l";
        }
    }

    private void EmitBlock(BlockNode block, Scope? scope = null)
    {
        _scopes.Push(scope ?? Scope.SubScope());

        foreach (var statement in block.Statements)
        {
            if (_codeIsReachable)
            {
                EmitStatement(statement);
            }
        }

        _scopes.Pop();

        _codeIsReachable = true;
    }

    private void EmitStatement(StatementNode statement)
    {
        switch (statement)
        {
            case AssignmentNode assignment:
                EmitAssignment(assignment);
                break;
            case BreakNode:
                EmitBreak();
                break;
            case ContinueNode:
                EmitContinue();
                break;
            case IfNode ifStatement:
                EmitIf(ifStatement);
                break;
            case ReturnNode @return:
                EmitReturn(@return);
                break;
            case StatementExpressionNode statementExpression:
                EmitExpression(statementExpression.Expression);
                break;
            case VariableDeclarationNode variableDeclaration:
                EmitVariableDeclaration(variableDeclaration);
                break;
            case WhileNode whileStatement:
                EmitWhile(whileStatement);
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(statement));
        }
    }

    private void EmitAssignment(AssignmentNode assignment)
    {
        var destination = EmitExpression(assignment.Target);
        if (destination.Kind != ValKind.Pointer)
        {
            throw new UnreachableException("Destination of assignment must be a pointer. This should be caught in the type checker");
        }

        EmitCopyIntoOrInitialize(assignment.Value, destination.Name);
    }

    private void EmitBreak()
    {
        _writer.Indented($"jmp {_breakLabels.Peek()}");
        _codeIsReachable = false;
    }

    private void EmitContinue()
    {
        _writer.Indented($"jmp {_continueLabels.Peek()}");
        _codeIsReachable = false;
    }

    private void EmitIf(IfNode ifStatement)
    {
        var trueLabel = LabelName();
        var falseLabel = LabelName();
        var endLabel = LabelName();

        var result = EmitUnwrap(EmitExpression(ifStatement.Condition));
        _writer.Indented($"jnz {result}, {trueLabel}, {falseLabel}");
        _writer.WriteLine(trueLabel);
        EmitBlock(ifStatement.Body);
        _writer.Indented($"jmp {endLabel}");
        _writer.WriteLine(falseLabel);
        if (ifStatement.Else.HasValue)
        {
            ifStatement.Else.Value.Match
            (
                elseIfNode => EmitIf(elseIfNode),
                elseNode => EmitBlock(elseNode)
            );
        }

        _writer.WriteLine(endLabel);
    }

    private void EmitReturn(ReturnNode @return)
    {
        if (@return.Value.HasValue)
        {
            var result = EmitUnwrap(EmitExpression(@return.Value.Value));
            _writer.Indented($"ret {result}");
        }
        else
        {
            _writer.Indented("ret");
        }
    }

    private void EmitVariableDeclaration(VariableDeclarationNode variableDeclaration)
    {
        var name = $"%{variableDeclaration.Name}";
        _writer.Indented($"{name} =l alloc8 8");

        if (variableDeclaration.Assignment.HasValue)
        {
            var value = EmitCreateCopyOrInitialize(variableDeclaration.Assignment.Value);
            EmitStore(variableDeclaration.Assignment.Value.Type, value, name);
        }

        Scope.Declare(variableDeclaration.Name, new Val(name, variableDeclaration.Type, ValKind.Pointer));
    }

    private void EmitWhile(WhileNode whileStatement)
    {
        var conditionLabel = LabelName();
        var iterationLabel = LabelName();
        var endLabel = LabelName();

        _breakLabels.Push(endLabel);
        _continueLabels.Push(conditionLabel);

        _writer.Indented($"jmp {conditionLabel}");
        _writer.WriteLine(iterationLabel);
        EmitBlock(whileStatement.Body);
        _writer.WriteLine(conditionLabel);
        var result = EmitUnwrap(EmitExpression(whileStatement.Condition));
        _writer.Indented($"jnz {result}, {iterationLabel}, {endLabel}");
        _writer.WriteLine(endLabel);

        _continueLabels.Pop();
        _breakLabels.Pop();
    }

    private Val EmitExpression(ExpressionNode expression)
    {
        return expression switch
        {
            ArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
            StructInitializerNode structInitializer => EmitStructInitializer(structInitializer),
            AddressOfNode addressOf => EmitAddressOf(addressOf),
            DereferenceNode dereference => EmitDereference(dereference),
            BinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
            FuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
            InterfaceFuncAccessNode interfaceFuncAccess => EmitInterfaceFuncAccess(interfaceFuncAccess),
            InterfaceFuncCallNode interfaceFuncCall => EmitInterfaceFuncCall(interfaceFuncCall),
            InterfaceInitializerNode interfaceInitializer => EmitInterfaceInitializer(interfaceInitializer),
            ExternFuncIdentNode externFuncIdent => EmitExternFuncIdent(externFuncIdent),
            LocalFuncIdentNode localFuncIdent => EmitLocalFuncIdent(localFuncIdent),
            VariableIdentNode variableIdent => EmitVariableIdent(variableIdent),
            LiteralNode literal => EmitLiteral(literal),
            UnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression),
            StructFieldAccessNode structFieldAccess => EmitStructFieldAccess(structFieldAccess),
            StructFuncAccessNode structFuncAccess => EmitStructFuncAccess(structFuncAccess),
            StructFuncCallNode structFuncCall => EmitStructFuncCall(structFuncCall),
            ArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex),
            _ => throw new ArgumentOutOfRangeException(nameof(expression))
        };
    }

    private Val EmitArrayIndexAccess(ArrayIndexAccessNode arrayIndexAccess)
    {
        var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Target));
        var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));

        EmitArraysCheck(array, index);

        var elementType = ((ArrayTypeNode)arrayIndexAccess.Target.Type).ElementType;

        var pointer = TmpName();
        _writer.Indented($"{pointer} =l mul {index}, {SizeOf(elementType)}");
        _writer.Indented($"{pointer} =l add {pointer}, 8");
        _writer.Indented($"{pointer} =l add {array}, {pointer}");
        return new Val(pointer, arrayIndexAccess.Type, ValKind.Pointer);
    }

    private void EmitArraysCheck(string array, string index)
    {
        var count = TmpName();
        _writer.Indented($"{count} =l loadl {array}");

        var isNegative = TmpName();
        _writer.Indented($"{isNegative} =w csltl {index}, 0");

        var isOob = TmpName();
        _writer.Indented($"{isOob} =w csgel {index}, {count}");

        var anyOob = TmpName();
        _writer.Indented($"{anyOob} =w or {isNegative}, {isOob}");

        var oobLabel = LabelName();
        var notOobLabel = LabelName();
        _writer.Indented($"jnz {anyOob}, {oobLabel}, {notOobLabel}");

        _writer.Indented(oobLabel);
        _writer.Indented($"call $nub_panic_array_oob()");

        _writer.Indented(notOobLabel);
    }

    private Val EmitArrayInitializer(ArrayInitializerNode arrayInitializer)
    {
        var capacity = EmitUnwrap(EmitExpression(arrayInitializer.Capacity));
        var elementSize = SizeOf(arrayInitializer.ElementType);

        var capacityInBytes = TmpName();
        _writer.Indented($"{capacityInBytes} =l mul {capacity}, {elementSize}");
        var totalSize = TmpName();
        _writer.Indented($"{totalSize} =l add {capacityInBytes}, 8");

        var arrayPointer = TmpName();
        _writer.Indented($"{arrayPointer} =l alloc8 {totalSize}");
        _writer.Indented($"storel {capacity}, {arrayPointer}");

        var dataPointer = TmpName();
        _writer.Indented($"{dataPointer} =l add {arrayPointer}, 8");
        _writer.Indented($"call $nub_memset(l {dataPointer}, w 0, l {capacityInBytes})");

        return new Val(arrayPointer, arrayInitializer.Type, ValKind.Direct);
    }

    private Val EmitDereference(DereferenceNode dereference)
    {
        return EmitLoad(dereference.Type, EmitUnwrap(EmitExpression(dereference.Expression)));
    }

    private Val EmitAddressOf(AddressOfNode addressOf)
    {
        var value = EmitExpression(addressOf.Expression);
        if (value.Kind != ValKind.Pointer)
        {
            throw new UnreachableException("Tried to take address of non-pointer type. This should have been caught in the type checker");
        }

        return new Val(value.Name, addressOf.Type, ValKind.Direct);
    }

    private Val EmitBinaryExpression(BinaryExpressionNode binaryExpression)
    {
        var left = EmitUnwrap(EmitExpression(binaryExpression.Left));
        var right = EmitUnwrap(EmitExpression(binaryExpression.Right));

        var outputName = TmpName();

        var instruction = EmitBinaryInstructionFor(binaryExpression.Operator, binaryExpression.Left.Type, left, right);

        _writer.Indented($"{outputName} {QBEAssign(binaryExpression.Left.Type)} {instruction} {left}, {right}");
        return new Val(outputName, binaryExpression.Type, ValKind.Direct);
    }

    private string EmitBinaryInstructionFor(BinaryOperator op, TypeNode type, string left, string right)
    {
        if (op is
            BinaryOperator.Equal or
            BinaryOperator.NotEqual or
            BinaryOperator.GreaterThan or
            BinaryOperator.GreaterThanOrEqual or
            BinaryOperator.LessThan or
            BinaryOperator.LessThanOrEqual)
        {
            char suffix;

            if (!type.IsSimpleType(out var simpleType, out _))
            {
                throw new NotSupportedException("Binary operations is only supported for simple types.");
            }

            switch (simpleType.StorageSize)
            {
                case StorageSize.I8:
                    _writer.Indented($"{left} =w extsb {left}");
                    _writer.Indented($"{right} =w extsb {right}");
                    suffix = 'w';
                    break;
                case StorageSize.U8:
                    _writer.Indented($"{left} =w extub {left}");
                    _writer.Indented($"{right} =w extub {right}");
                    suffix = 'w';
                    break;
                case StorageSize.I16:
                    _writer.Indented($"{left} =w extsh {left}");
                    _writer.Indented($"{right} =w extsh {right}");
                    suffix = 'w';
                    break;
                case StorageSize.U16:
                    _writer.Indented($"{left} =w extuh {left}");
                    _writer.Indented($"{right} =w extuh {right}");
                    suffix = 'w';
                    break;
                case StorageSize.I32 or StorageSize.U32:
                    suffix = 'w';
                    break;
                case StorageSize.I64 or StorageSize.U64:
                    suffix = 'l';
                    break;
                default:
                    throw new NotSupportedException($"Unsupported type '{simpleType}' for binary operator '{op}'");
            }

            if (op is BinaryOperator.Equal)
            {
                return "ceq" + suffix;
            }

            if (op is BinaryOperator.NotEqual)
            {
                return "cne" + suffix;
            }

            string sign;

            if (simpleType is IntTypeNode { Signed: true })
            {
                sign = "s";
            }
            else if (simpleType is IntTypeNode { Signed: false })
            {
                sign = "u";
            }
            else
            {
                throw new NotSupportedException($"Unsupported type '{type}' for binary operator '{op}'");
            }

            return op switch
            {
                BinaryOperator.GreaterThan => 'c' + sign + "gt" + suffix,
                BinaryOperator.GreaterThanOrEqual => 'c' + sign + "ge" + suffix,
                BinaryOperator.LessThan => 'c' + sign + "lt" + suffix,
                BinaryOperator.LessThanOrEqual => 'c' + sign + "le" + suffix,
                _ => throw new ArgumentOutOfRangeException(nameof(op), op, null)
            };
        }

        return op switch
        {
            BinaryOperator.Plus => "add",
            BinaryOperator.Minus => "sub",
            BinaryOperator.Multiply => "mul",
            BinaryOperator.Divide => "div",
            _ => throw new ArgumentOutOfRangeException(nameof(op))
        };
    }

    private Val EmitExternFuncIdent(ExternFuncIdentNode externFuncIdent)
    {
        var func = _definitionTable.LookupExternFunc(externFuncIdent.Name);
        return new Val(ExternFuncName(func), externFuncIdent.Type, ValKind.Direct);
    }

    private Val EmitLocalFuncIdent(LocalFuncIdentNode localFuncIdent)
    {
        var func = _definitionTable.LookupLocalFunc(localFuncIdent.Name);
        return new Val(LocalFuncName(func), localFuncIdent.Type, ValKind.Direct);
    }

    private Val EmitVariableIdent(VariableIdentNode variableIdent)
    {
        return Scope.Lookup(variableIdent.Name);
    }

    private Val EmitLiteral(LiteralNode literal)
    {
        switch (literal.Kind)
        {
            case LiteralKind.Integer:
            {
                if (literal.Type is FloatTypeNode { Width: 32 })
                {
                    var value = float.Parse(literal.Value, CultureInfo.InvariantCulture);
                    var bits = BitConverter.SingleToInt32Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type is FloatTypeNode { Width: 64 })
                {
                    var value = double.Parse(literal.Value, CultureInfo.InvariantCulture);
                    var bits = BitConverter.DoubleToInt64Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type is IntTypeNode)
                {
                    return new Val(literal.Value, literal.Type, ValKind.Direct);
                }

                break;
            }
            case LiteralKind.Float:
            {
                if (literal.Type is IntTypeNode)
                {
                    return new Val(literal.Value.Split(".").First(), literal.Type, ValKind.Direct);
                }

                if (literal.Type is FloatTypeNode { Width: 32 })
                {
                    var value = float.Parse(literal.Value, CultureInfo.InvariantCulture);
                    var bits = BitConverter.SingleToInt32Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type is FloatTypeNode { Width: 64 })
                {
                    var value = double.Parse(literal.Value, CultureInfo.InvariantCulture);
                    var bits = BitConverter.DoubleToInt64Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                break;
            }
            case LiteralKind.String:
            {
                if (literal.Type is StringTypeNode)
                {
                    var stringLiteral = new StringLiteral(literal.Value, StringName());
                    _stringLiterals.Add(stringLiteral);
                    return new Val(stringLiteral.Name, literal.Type, ValKind.Direct);
                }

                if (literal.Type is CStringTypeNode)
                {
                    var cStringLiteral = new CStringLiteral(literal.Value, CStringName());
                    _cStringLiterals.Add(cStringLiteral);
                    return new Val(cStringLiteral.Name, literal.Type, ValKind.Direct);
                }

                break;
            }
            case LiteralKind.Bool:
            {
                if (literal.Type is BoolTypeNode)
                {
                    return new Val(bool.Parse(literal.Value) ? "1" : "0", literal.Type, ValKind.Direct);
                }

                break;
            }
        }

        throw new NotSupportedException($"Cannot create literal of kind '{literal.Kind}' for type {literal.Type}");
    }

    private Val EmitStructInitializer(StructInitializerNode structInitializer, string? destination = null)
    {
        var structDef = _definitionTable.LookupStruct(structInitializer.StructType.Name);

        if (destination == null)
        {
            destination = TmpName();
            var size = SizeOf(structInitializer.StructType);
            _writer.Indented($"{destination} =l alloc8 {size}");
        }

        foreach (var field in structDef.Fields)
        {
            if (!structInitializer.Initializers.TryGetValue(field.Name, out var valueExpression))
            {
                valueExpression = field.Value.Value;
            }

            if (valueExpression == null)
            {
                throw new UnreachableException("Value of field in uninitialized. This should have been caught in the type checker");
            }

            var offset = TmpName();
            _writer.Indented($"{offset} =l add {destination}, {OffsetOf(structDef, field.Name)}");
            EmitCopyIntoOrInitialize(valueExpression, offset);
        }

        return new Val(destination, structInitializer.StructType, ValKind.Direct);
    }

    private Val EmitUnaryExpression(UnaryExpressionNode unaryExpression)
    {
        var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
        var outputName = TmpName();

        switch (unaryExpression.Operator)
        {
            case UnaryOperator.Negate:
            {
                switch (unaryExpression.Operand.Type)
                {
                    case IntTypeNode { Signed: true, Width: 64 }:
                        _writer.Indented($"{outputName} =l neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case IntTypeNode { Signed: true, Width: 8 or 16 or 32 }:
                        _writer.Indented($"{outputName} =w neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case FloatTypeNode { Width: 64 }:
                        _writer.Indented($"{outputName} =d neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case FloatTypeNode { Width: 32 }:
                        _writer.Indented($"{outputName} =s neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                }

                break;
            }
            case UnaryOperator.Invert:
            {
                switch (unaryExpression.Operand.Type)
                {
                    case BoolTypeNode:
                        _writer.Indented($"{outputName} =w xor {operand}, 1");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                }

                break;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }

        throw new NotSupportedException($"Unary operator {unaryExpression.Operator} for type {unaryExpression.Operand.Type} not supported");
    }

    private Val EmitStructFieldAccess(StructFieldAccessNode structFieldAccess)
    {
        var target = EmitUnwrap(EmitExpression(structFieldAccess.Target));

        var structDef = _definitionTable.LookupStruct(structFieldAccess.StructType.Name);
        var offset = OffsetOf(structDef, structFieldAccess.Field);

        var output = TmpName();
        _writer.Indented($"{output} =l add {target}, {offset}");

        // If the accessed member is an inline struct, it will not be a pointer
        if (structFieldAccess.Type is StructTypeNode)
        {
            return new Val(output, structFieldAccess.Type, ValKind.Direct);
        }

        return new Val(output, structFieldAccess.Type, ValKind.Pointer);
    }

    private Val EmitStructFuncAccess(StructFuncAccessNode structFuncAccess)
    {
        var structDef = _definitionTable.LookupStruct(structFuncAccess.StructType.Name);
        var func = StructFuncName(structDef.Name, structFuncAccess.Func);

        return new Val(func, structFuncAccess.Type, ValKind.Direct);
    }

    private Val EmitStructFuncCall(StructFuncCallNode structFuncCall)
    {
        var expression = EmitExpression(structFuncCall.Expression);
        var thisParameter = EmitUnwrap(EmitExpression(structFuncCall.StructExpression));

        List<string> parameterStrings = [$"l {thisParameter}"];

        foreach (var parameter in structFuncCall.Parameters)
        {
            var copy = EmitCreateCopyOrInitialize(parameter);
            parameterStrings.Add($"{FuncQBETypeName(parameter.Type)} {copy}");
        }

        var funcPointer = EmitUnwrap(expression);
        if (structFuncCall.Type is VoidTypeNode)
        {
            _writer.Indented($"call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(string.Empty, structFuncCall.Type, ValKind.Direct);
        }
        else
        {
            var outputName = TmpName();
            _writer.Indented($"{outputName} {QBEAssign(structFuncCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(outputName, structFuncCall.Type, ValKind.Direct);
        }
    }

    private Val EmitInterfaceFuncAccess(InterfaceFuncAccessNode interfaceFuncAccess)
    {
        var target = EmitUnwrap(EmitExpression(interfaceFuncAccess.Target));

        var interfaceDef = _definitionTable.LookupInterface(interfaceFuncAccess.InterfaceType.Name);
        var functionIndex = interfaceDef.Functions.ToList().FindIndex(x => x.Name == interfaceFuncAccess.FuncName);
        var offset = functionIndex * 8;

        var vtable = TmpName();
        _writer.Indented($"{vtable} =l loadl {target}");

        var funcOffset = TmpName();
        _writer.Indented($"{funcOffset} =l add {vtable}, {offset}");

        var func = TmpName();
        _writer.Indented($"{func} =l loadl {funcOffset}");

        return new Val(func, interfaceFuncAccess.Type, ValKind.Direct);
    }

    private Val EmitInterfaceFuncCall(InterfaceFuncCallNode interfaceFuncCall)
    {
        var expression = EmitExpression(interfaceFuncCall.Expression);

        var thisParameter = EmitUnwrap(EmitExpression(interfaceFuncCall.InterfaceExpression));
        _writer.Indented($"{thisParameter} =l add {thisParameter}, 8");
        _writer.Indented($"{thisParameter} =l loadl {thisParameter}");

        List<string> parameterStrings = [$"l {thisParameter}"];

        foreach (var parameter in interfaceFuncCall.Parameters)
        {
            var copy = EmitCreateCopyOrInitialize(parameter);
            parameterStrings.Add($"{FuncQBETypeName(parameter.Type)} {copy}");
        }

        var funcPointer = EmitUnwrap(expression);
        if (interfaceFuncCall.Type is VoidTypeNode)
        {
            _writer.Indented($"call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(string.Empty, interfaceFuncCall.Type, ValKind.Direct);
        }
        else
        {
            var outputName = TmpName();
            _writer.Indented($"{outputName} {QBEAssign(interfaceFuncCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(outputName, interfaceFuncCall.Type, ValKind.Direct);
        }
    }

    private Val EmitInterfaceInitializer(InterfaceInitializerNode interfaceInitializer, string? destination = null)
    {
        var implementation = EmitUnwrap(EmitExpression(interfaceInitializer.Implementation));

        var vtableOffset = 0;
        foreach (var interfaceImplementation in interfaceInitializer.StructType.InterfaceImplementations)
        {
            if (interfaceImplementation == interfaceInitializer.InterfaceType)
            {
                break;
            }

            vtableOffset += interfaceImplementation.Functions.Count * 8;
        }

        if (destination == null)
        {
            destination = TmpName();
            _writer.Indented($"{destination} =l alloc8 {SizeOf(interfaceInitializer.InterfaceType)}");
        }

        var interfaceVtablePointer = TmpName();
        _writer.Indented($"{interfaceVtablePointer} =l add {StructVtableName(interfaceInitializer.StructType.Name)}, {vtableOffset}");
        _writer.Indented($"storel {interfaceVtablePointer}, {destination}");

        var objectPointer = TmpName();
        _writer.Indented($"{objectPointer} =l add {destination}, 8");
        _writer.Indented($"storel {implementation}, {objectPointer}");

        return new Val(destination, interfaceInitializer.InterfaceType, ValKind.Direct);
    }

    private Val EmitFuncCall(FuncCallNode funcCall)
    {
        var expression = EmitExpression(funcCall.Expression);

        var parameterStrings = new List<string>();

        foreach (var parameter in funcCall.Parameters)
        {
            var copy = EmitCreateCopyOrInitialize(parameter);
            parameterStrings.Add($"{FuncQBETypeName(parameter.Type)} {copy}");
        }

        var funcPointer = EmitUnwrap(expression);
        if (funcCall.Type is VoidTypeNode)
        {
            _writer.Indented($"call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(string.Empty, funcCall.Type, ValKind.Direct);
        }
        else
        {
            var outputName = TmpName();
            _writer.Indented($"{outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(outputName, funcCall.Type, ValKind.Direct);
        }
    }

    private string EmitUnwrap(Val val)
    {
        return val.Kind switch
        {
            ValKind.Direct => val.Name,
            ValKind.Pointer => EmitLoad(val.Type, val.Name).Name,
            _ => throw new ArgumentOutOfRangeException()
        };
    }

    private static int SizeOf(TypeNode type)
    {
        return type switch
        {
            SimpleTypeNode simple => simple.StorageSize switch
            {
                StorageSize.Void => 0,
                StorageSize.I8 or StorageSize.U8 => 1,
                StorageSize.I16 or StorageSize.U16 => 2,
                StorageSize.I32 or StorageSize.U32 or StorageSize.F32 => 4,
                StorageSize.I64 or StorageSize.U64 or StorageSize.F64 => 8,
                _ => throw new ArgumentOutOfRangeException(nameof(type), $"Unknown storage size: {simple.StorageSize}")
            },
            CStringTypeNode => 8,
            StringTypeNode => 8,
            ArrayTypeNode => 8,
            StructTypeNode structType => CalculateStructSize(structType),
            InterfaceTypeNode => 16,
            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Unknown type: {type.GetType()}")
        };
    }

    private static int CalculateStructSize(StructTypeNode structType)
    {
        var offset = 0;

        foreach (var field in structType.Fields)
        {
            var fieldAlignment = AlignmentOf(field);
            offset = AlignTo(offset, fieldAlignment);
            offset += SizeOf(field);
        }

        var structAlignment = CalculateStructAlignment(structType);
        return AlignTo(offset, structAlignment);
    }

    private static int AlignmentOf(TypeNode type)
    {
        return type switch
        {
            SimpleTypeNode simple => simple.StorageSize switch
            {
                StorageSize.Void => 1,
                StorageSize.I8 or StorageSize.U8 => 1,
                StorageSize.I16 or StorageSize.U16 => 2,
                StorageSize.I32 or StorageSize.U32 or StorageSize.F32 => 4,
                StorageSize.I64 or StorageSize.U64 or StorageSize.F64 => 8,
                _ => throw new ArgumentOutOfRangeException(nameof(type), $"Unknown storage size: {simple.StorageSize}")
            },
            CStringTypeNode => 8,
            StringTypeNode => 8,
            ArrayTypeNode => 8,
            StructTypeNode structType => CalculateStructAlignment(structType),
            InterfaceTypeNode => 8,
            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Unknown type: {type.GetType()}")
        };
    }

    private static int CalculateStructAlignment(StructTypeNode structType)
    {
        var maxAlignment = 1;

        if (structType.InterfaceImplementations.Any())
        {
            maxAlignment = Math.Max(maxAlignment, 8);
        }

        foreach (var field in structType.Fields)
        {
            var fieldAlignment = AlignmentOf(field);
            maxAlignment = Math.Max(maxAlignment, fieldAlignment);
        }

        return maxAlignment;
    }

    private static int AlignTo(int offset, int alignment)
    {
        return (offset + alignment - 1) & ~(alignment - 1);
    }

    private int OffsetOf(StructNode structDef, string member)
    {
        var offset = 0;

        // if (structDef.InterfaceImplementations.Any())
        // {
        //     offset = 8;
        // }

        foreach (var field in structDef.Fields)
        {
            if (field.Name == member)
            {
                return offset;
            }

            var fieldAlignment = AlignmentOf(field.Type);

            offset = AlignTo(offset, fieldAlignment);
            offset += SizeOf(field.Type);
        }

        throw new UnreachableException($"Member '{member}' not found in struct");
    }

    #region Naming utilities

    private string TmpName()
    {
        return $"%t{++_tmpIndex}";
    }

    private string LabelName()
    {
        return $"@l{++_labelIndex}";
    }

    private string CStringName()
    {
        return $"$cstring{++_cStringLiteralIndex}";
    }

    private string StringName()
    {
        return $"$string{++_stringLiteralIndex}";
    }

    private string LocalFuncName(LocalFuncNode funcDef)
    {
        return $"${funcDef.Name}";
    }

    private string ExternFuncName(ExternFuncNode funcDef)
    {
        return $"${funcDef.CallName}";
    }

    private string StructTypeName(string name)
    {
        return $":{name}";
    }

    private string StructFuncName(string structName, string funcName)
    {
        return $"${structName}_{funcName}";
    }

    private string StructVtableName(string structName)
    {
        return $"${structName}_vtable";
    }

    #endregion
}

public class StringLiteral(string value, string name)
{
    public string Value { get; } = value;
    public string Name { get; } = name;
}

public class CStringLiteral(string value, string name)
{
    public string Value { get; } = value;
    public string Name { get; } = name;
}

public record Val(string Name, TypeNode Type, ValKind Kind);

public class Scope(Scope? parent = null)
{
    private readonly Dictionary<string, Val> _variables = [];

    public Val Lookup(string name)
    {
        var variable = _variables.GetValueOrDefault(name);
        if (variable != null)
        {
            return variable;
        }

        return parent?.Lookup(name) ?? throw new UnreachableException($"Variable '{name}' not found");
    }

    public void Declare(string name, Val value)
    {
        _variables.Add(name, value);
    }

    public Scope SubScope()
    {
        return new Scope(this);
    }
}

public enum ValKind
{
    Pointer,
    Direct,
}