using System.Diagnostics;
using System.Globalization;
using System.Text;
using Syntax;
using Syntax.Parsing.Node;
using Syntax.Tokenization;
using Syntax.Typing;
using Syntax.Typing.BoundNode;

namespace Generation.QBE;

public static class QBEGenerator
{
    private static BoundSyntaxTree _syntaxTree = null!;
    private static BoundDefinitionTable _definitionTable = null!;

    private static StringBuilder _builder = new();
    private static List<CStringLiteral> _cStringLiterals = [];
    private static List<StringLiteral> _stringLiterals = [];
    private static Stack<string> _breakLabels = [];
    private static Stack<string> _continueLabels = [];
    private static Queue<(BoundAnonymousFuncNode Func, string Name)> _anonymousFunctions = [];
    private static Stack<Variable> _variables = [];
    private static Stack<int> _variableScopes = [];
    private static int _variableIndex;
    private static int _labelIndex;
    private static int _anonymousFuncIndex;
    private static int _cStringLiteralIndex;
    private static int _stringLiteralIndex;
    private static bool _codeIsReachable = true;

    public static string Emit(BoundSyntaxTree syntaxTree, BoundDefinitionTable definitionTable)
    {
        _syntaxTree = syntaxTree;
        _definitionTable = definitionTable;

        _builder = new StringBuilder();
        _cStringLiterals = [];
        _stringLiterals = [];
        _breakLabels = [];
        _continueLabels = [];
        _anonymousFunctions = [];
        _variables = [];
        _variableScopes = [];
        _variableIndex = 0;
        _labelIndex = 0;
        _anonymousFuncIndex = 0;
        _cStringLiteralIndex = 0;
        _stringLiteralIndex = 0;
        _codeIsReachable = true;

        foreach (var structDef in _definitionTable.GetStructs())
        {
            EmitStructDefinition(structDef);
            _builder.AppendLine();
        }

        foreach (var funcDef in _syntaxTree.Definitions.OfType<BoundLocalFuncDefinitionNode>())
        {
            EmitFuncDefinition(FuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
            _builder.AppendLine();
        }

        while (_anonymousFunctions.TryDequeue(out var anon))
        {
            EmitFuncDefinition(anon.Name, anon.Func.Parameters, anon.Func.ReturnType, anon.Func.Body, false);
            _builder.AppendLine();
        }

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

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

        return _builder.ToString();
    }

    private static string VarName()
    {
        return $"%v{++_variableIndex}";
    }

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

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

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

    private static string FuncName(BoundFuncDefinition funcDef)
    {
        return funcDef switch
        {
            BoundExternFuncDefinitionNode externFuncDefinition => $"${externFuncDefinition.CallName}",
            BoundLocalFuncDefinitionNode localFuncDefinition => localFuncDefinition.Exported
                ? $"${localFuncDefinition.Name}"
                : $"${localFuncDefinition.Namespace}_{localFuncDefinition.Name}",
            _ => throw new ArgumentOutOfRangeException(nameof(funcDef))
        };
    }

    private static string StructName(BoundStructDefinitionNode structDef)
    {
        return $":{structDef.Namespace}_{structDef.Name}";
    }

    private static void EmitStore(NubType type, string value, string destination)
    {
        var store = type switch
        {
            NubArrayType => "storel",
            NubPointerType => "storel",
            NubPrimitiveType primitiveType => primitiveType.Kind switch
            {
                PrimitiveTypeKind.I64 => "storel",
                PrimitiveTypeKind.I32 => "storew",
                PrimitiveTypeKind.I16 => "storeh",
                PrimitiveTypeKind.I8 => "storeb",
                PrimitiveTypeKind.U64 => "storel",
                PrimitiveTypeKind.U32 => "storew",
                PrimitiveTypeKind.U16 => "storeh",
                PrimitiveTypeKind.U8 => "storeb",
                PrimitiveTypeKind.F64 => "stored",
                PrimitiveTypeKind.F32 => "stores",
                PrimitiveTypeKind.Bool => "storew",
                _ => throw new ArgumentOutOfRangeException()
            },
            NubStructType => "storel",
            NubFuncType => "storel",
            NubCStringType => "storel",
            NubStringType => "storel",
            _ => throw new NotSupportedException($"'{type}' type cannot be used in store instructions")
        };

        _builder.AppendLine($"    {store} {value}, {destination}");
    }

    private static Val EmitLoad(NubType type, string from)
    {
        var into = VarName();
        var load = type switch
        {
            NubArrayType => "loadl",
            NubPointerType => "loadl",
            NubPrimitiveType primitiveType => primitiveType.Kind switch
            {
                PrimitiveTypeKind.I64 => "loadl",
                PrimitiveTypeKind.I32 => "loadw",
                PrimitiveTypeKind.I16 => "loadsh",
                PrimitiveTypeKind.I8 => "loadsb",
                PrimitiveTypeKind.U64 => "loadl",
                PrimitiveTypeKind.U32 => "loadw",
                PrimitiveTypeKind.U16 => "loaduh",
                PrimitiveTypeKind.U8 => "loadub",
                PrimitiveTypeKind.F64 => "loadd",
                PrimitiveTypeKind.F32 => "loads",
                PrimitiveTypeKind.Bool => "loadw",
                _ => throw new ArgumentOutOfRangeException()
            },
            NubStructType => "loadl",
            NubFuncType => "loadl",
            NubCStringType => "loadl",
            NubStringType => "loadl",
            _ => throw new NotSupportedException($"'{type}' type cannot be used in load instructions")
        };

        _builder.AppendLine($"    {into} {QBEAssign(type)} {load} {from}");

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

    private static void EmitMemcpy(string source, string destination, string length)
    {
        _builder.AppendLine($"    call $nub_memcpy(l {source}, l {destination}, l {length})");
    }

    private static string EmitArraySizeInBytes(NubArrayType type, string array)
    {
        var size = VarName();
        _builder.AppendLine($"    {size} =l loadl {array}");
        _builder.AppendLine($"    {size} =l mul {size}, {SizeOf(type.ElementType)}");
        _builder.AppendLine($"    {size} =l add {size}, 8");
        return size;
    }

    private static string EmitCStringSizeInBytes(string cstring)
    {
        var size = VarName();
        _builder.AppendLine($"    {size} =l call $nub_cstring_length(l {cstring})");
        _builder.AppendLine($"    {size} =l add {size}, 1");
        return size;
    }

    private static string EmitStringSizeInBytes(string nubstring)
    {
        var size = VarName();
        _builder.AppendLine($"    {size} =l loadl {nubstring}");
        _builder.AppendLine($"    {size} =l add {size}, 8");
        return size;
    }

    private static void EmitCopyInto(NubType type, string source, string destination)
    {
        switch (type)
        {
            case NubArrayType nubArrayType:
            {
                var size = EmitArraySizeInBytes(nubArrayType, source);
                var buffer = VarName();
                _builder.AppendLine($"    {buffer} =l alloc8 {size}");
                EmitMemcpy(source, buffer, size);
                EmitStore(type, buffer, destination);
                break;
            }
            case NubCStringType:
            {
                var size = EmitCStringSizeInBytes(source);
                var buffer = VarName();
                _builder.AppendLine($"    {buffer} =l alloc8 {size}");
                EmitMemcpy(source, buffer, size);
                EmitStore(type, buffer, destination);
                break;
            }
            case NubStringType:
            {
                var size = EmitStringSizeInBytes(source);
                var buffer = VarName();
                _builder.AppendLine($"    {buffer} =l alloc8 {size}");
                EmitMemcpy(source, buffer, size);
                EmitStore(type, buffer, destination);
                break;
            }
            case NubStructType nubStructType:
            {
                var size = SizeOf(nubStructType);
                EmitMemcpy(source, destination, size.ToString());
                break;
            }
            case NubPointerType:
            case NubPrimitiveType:
            {
                EmitStore(type, source, destination);
                break;
            }
            case NubVoidType:
            case NubFuncType:
            case NubAnyType:
                throw new NotSupportedException($"Cannot copy type '{type}'");
            default:
                throw new ArgumentOutOfRangeException(nameof(type));
        }
    }
    
    private static string EmitCopy(NubType type, string source)
    {
        var destination = VarName();
        switch (type)
        {
            case NubArrayType nubArrayType:
            {
                var size = EmitArraySizeInBytes(nubArrayType, source);
                _builder.AppendLine($"    {destination} =l alloc8 {size}");
                EmitMemcpy(source, destination, size);
                break;
            }
            case NubCStringType:
            {
                var size = EmitCStringSizeInBytes(source);
                _builder.AppendLine($"    {destination} =l alloc8 {size}");
                EmitMemcpy(source, destination, size);
                break;
            }
            case NubStringType:
            {
                var size = EmitStringSizeInBytes(source);
                _builder.AppendLine($"    {destination} =l alloc8 {size}");
                EmitMemcpy(source, destination, size);
                break;
            }
            case NubStructType nubStructType:
            {
                var size = SizeOf(nubStructType);
                _builder.AppendLine($"    {destination} =l alloc8 {size}");
                EmitMemcpy(source, destination, size.ToString());
                break;
            }
            case NubPointerType:
            case NubPrimitiveType:
            {
                _builder.AppendLine($"    {destination} {QBEAssign(type)} {source}");
                break;
            }
            case NubVoidType:
            case NubFuncType:
            case NubAnyType:
                throw new NotSupportedException($"Cannot copy type '{type}'");
            default:
                throw new ArgumentOutOfRangeException(nameof(type));
        }
        
        return destination;
    }

    private static string QBEAssign(NubType type)
    {
        return type switch
        {
            NubArrayType => "=l",
            NubPointerType => "=l",
            NubPrimitiveType primitiveType => primitiveType.Kind switch
            {
                PrimitiveTypeKind.I64 => "=l",
                PrimitiveTypeKind.I32 => "=w",
                PrimitiveTypeKind.I16 => "=w",
                PrimitiveTypeKind.I8 => "=w",
                PrimitiveTypeKind.U64 => "=l",
                PrimitiveTypeKind.U32 => "=w",
                PrimitiveTypeKind.U16 => "=w",
                PrimitiveTypeKind.U8 => "=w",
                PrimitiveTypeKind.F64 => "=d",
                PrimitiveTypeKind.F32 => "=s",
                PrimitiveTypeKind.Bool => "=w",
                _ => throw new ArgumentOutOfRangeException()
            },
            NubStructType => "=l",
            NubFuncType => "=l",
            NubCStringType => "=l",
            NubStringType => "=l",
            _ => throw new NotSupportedException($"'{type}' type cannot be used in variables")
        };
    }

    private static int AlignmentOf(NubType type)
    {
        switch (type)
        {
            case NubPrimitiveType primitiveType:
            {
                return primitiveType.Kind switch
                {
                    PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 or PrimitiveTypeKind.F64 => 8,
                    PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.F32 or PrimitiveTypeKind.Bool => 4,
                    PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => 2,
                    PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 => 1,
                    _ => throw new ArgumentOutOfRangeException()
                };
            }
            case NubStructType nubStructType:
            {
                var definition = _definitionTable.LookupStruct(nubStructType.Namespace, nubStructType.Name).GetValue();
                return definition.Fields.Max(f => AlignmentOf(f.Type));
            }
            case NubPointerType:
            case NubArrayType:
            case NubCStringType:
            case NubStringType:
            case NubFuncType:
            {
                return 8;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

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

    private static int SizeOf(NubType type)
    {
        switch (type)
        {
            case NubPrimitiveType primitiveType:
            {
                return primitiveType.Kind switch
                {
                    PrimitiveTypeKind.I64 or PrimitiveTypeKind.U64 or PrimitiveTypeKind.F64 => 8,
                    PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.F32 or PrimitiveTypeKind.Bool => 4,
                    PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => 2,
                    PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 => 1,
                    _ => throw new ArgumentOutOfRangeException()
                };
            }
            case NubStructType nubStructType:
            {
                var definition = _definitionTable.LookupStruct(nubStructType.Namespace, nubStructType.Name).GetValue();

                var size = 0;
                var maxAlignment = 1;

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

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

                size = AlignTo(size, maxAlignment);

                return size;
            }
            case NubPointerType:
            case NubArrayType:
            case NubCStringType:
            case NubStringType:
            case NubFuncType:
            {
                return 8;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

    private static int OffsetOf(BoundStructDefinitionNode structDefinition, string member)
    {
        var offset = 0;

        foreach (var field in structDefinition.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");
    }

    private static void EmitFuncDefinition(string name, List<BoundFuncParameter> parameters, NubType returnType, BoundBlockNode body, bool exported)
    {
        _variables.Clear();
        _variableScopes.Clear();

        if (exported)
        {
            _builder.Append("export ");
        }

        _builder.Append("function ");
        if (returnType is not NubVoidType)
        {
            _builder.Append(returnType switch
            {
                NubArrayType => "l",
                NubPointerType => "l",
                NubPrimitiveType primitiveType => primitiveType.Kind switch
                {
                    PrimitiveTypeKind.I64 => "l",
                    PrimitiveTypeKind.I32 => "w",
                    PrimitiveTypeKind.I16 => "sh",
                    PrimitiveTypeKind.I8 => "sb",
                    PrimitiveTypeKind.U64 => "l",
                    PrimitiveTypeKind.U32 => "w",
                    PrimitiveTypeKind.U16 => "uh",
                    PrimitiveTypeKind.U8 => "ub",
                    PrimitiveTypeKind.F64 => "d",
                    PrimitiveTypeKind.F32 => "s",
                    PrimitiveTypeKind.Bool => "w",
                    _ => throw new ArgumentOutOfRangeException()
                },
                NubStructType structType => StructName(_definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue()),
                NubFuncType => "l",
                NubCStringType => "l",
                NubStringType => "l",
                _ => throw new NotSupportedException($"'{returnType}' type cannot be used as a function return type")
            });
            _builder.Append(' ');
        }

        _builder.Append(name);

        var parameterStrings = parameters.Select(parameter =>
        {
            var qbeType = parameter.Type switch
            {
                NubArrayType => "l",
                NubPointerType => "l",
                NubPrimitiveType primitiveType => primitiveType.Kind switch
                {
                    PrimitiveTypeKind.I64 => "l",
                    PrimitiveTypeKind.I32 => "w",
                    PrimitiveTypeKind.I16 => "sh",
                    PrimitiveTypeKind.I8 => "sb",
                    PrimitiveTypeKind.U64 => "l",
                    PrimitiveTypeKind.U32 => "w",
                    PrimitiveTypeKind.U16 => "uh",
                    PrimitiveTypeKind.U8 => "ub",
                    PrimitiveTypeKind.F64 => "d",
                    PrimitiveTypeKind.F32 => "s",
                    PrimitiveTypeKind.Bool => "w",
                    _ => throw new ArgumentOutOfRangeException()
                },
                NubStructType structType => StructName(_definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue()),
                NubFuncType => "l",
                NubCStringType => "l",
                NubStringType => "l",
                _ => throw new NotSupportedException($"'{parameter.Type}' type cannot be used as a function parameter type")
            };

            return $"{qbeType} %{parameter.Name}";
        });

        _builder.AppendLine($"({string.Join(", ", parameterStrings)}) {{");
        _builder.AppendLine("@start");

        List<Variable> parameterVars = [];

        foreach (var parameter in parameters)
        {
            var parameterName = "%" + parameter.Name;

            if (parameter.Type is NubPrimitiveType primitiveType)
            {
                switch (primitiveType.Kind)
                {
                    case PrimitiveTypeKind.I16:
                        parameterName = VarName();
                        _builder.AppendLine($"    {parameterName} =w extsh %{parameter.Name}");
                        break;
                    case PrimitiveTypeKind.I8:
                        parameterName = VarName();
                        _builder.AppendLine($"    {parameterName} =w extsb %{parameter.Name}");
                        break;
                    case PrimitiveTypeKind.U16:
                        parameterName = VarName();
                        _builder.AppendLine($"    {parameterName} =w extuh %{parameter.Name}");
                        break;
                    case PrimitiveTypeKind.U8:
                        parameterName = VarName();
                        _builder.AppendLine($"    {parameterName} =w extub %{parameter.Name}");
                        break;
                }
            }

            parameterVars.Add(new Variable(parameter.Name, new Val(parameterName, parameter.Type, ValKind.Direct)));
        }

        EmitBlock(body, parameterVars);

        if (body.Statements.LastOrDefault() is not BoundReturnNode)
        {
            if (returnType is NubVoidType)
            {
                _builder.AppendLine("    ret");
            }
        }

        _builder.AppendLine("}");
    }

    private static void EmitStructDefinition(BoundStructDefinitionNode structDefinition)
    {
        _builder.Append($"type {StructName(structDefinition)} = {{ ");
        foreach (var structDefinitionField in structDefinition.Fields)
        {
            var qbeType = structDefinitionField.Type switch
            {
                NubArrayType => "l",
                NubPointerType => "l",
                NubPrimitiveType primitiveType => primitiveType.Kind switch
                {
                    PrimitiveTypeKind.I64 => "l",
                    PrimitiveTypeKind.I32 => "w",
                    PrimitiveTypeKind.I16 => "h",
                    PrimitiveTypeKind.I8 => "b",
                    PrimitiveTypeKind.U64 => "l",
                    PrimitiveTypeKind.U32 => "w",
                    PrimitiveTypeKind.U16 => "h",
                    PrimitiveTypeKind.U8 => "b",
                    PrimitiveTypeKind.F64 => "d",
                    PrimitiveTypeKind.F32 => "s",
                    PrimitiveTypeKind.Bool => "w",
                    _ => throw new ArgumentOutOfRangeException()
                },
                NubStructType structType => StructName(_definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue()),
                NubFuncType => "l",
                NubCStringType => "l",
                NubStringType => "l",
                _ => throw new NotSupportedException($"'{structDefinitionField.Type}' type cannot be used in structs")
            };
            _builder.Append(qbeType + ", ");
        }

        _builder.AppendLine("}");
    }

    private static void EmitStatement(BoundStatementNode statement)
    {
        switch (statement)
        {
            case BoundAssignmentNode assignment:
                EmitAssignment(assignment);
                break;
            case BoundBreakNode:
                EmitBreak();
                break;
            case BoundContinueNode:
                EmitContinue();
                break;
            case BoundIfNode ifStatement:
                EmitIf(ifStatement);
                break;
            case BoundReturnNode @return:
                EmitReturn(@return);
                break;
            case BoundStatementExpressionNode statementExpression:
                EmitExpression(statementExpression.Expression);
                break;
            case BoundVariableDeclarationNode variableDeclaration:
                EmitVariableDeclaration(variableDeclaration);
                break;
            case BoundWhileNode whileStatement:
                EmitWhile(whileStatement);
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(statement));
        }
    }

    private static void EmitAssignment(BoundAssignmentNode assignment)
    {
        var destination = EmitExpression(assignment.Expression);
        Debug.Assert(destination.Kind == ValKind.Pointer);
        
        var source = EmitUnwrap(EmitExpression(assignment.Value));
        EmitCopyInto(assignment.Value.Type, source, destination.Name);
    }

    private static void EmitBlock(BoundBlockNode block, List<Variable>? variables = null)
    {
        _variableScopes.Push(_variables.Count);
        if (variables != null)
        {
            foreach (var variable in variables)
            {
                _variables.Push(variable);
            }
        }

        foreach (var statement in block.Statements.Where(_ => _codeIsReachable))
        {
            EmitStatement(statement);
        }

        var count = _variableScopes.Pop();
        while (_variableScopes.Count > count)
        {
            _variableScopes.Pop();
        }

        _codeIsReachable = true;
    }

    private static void EmitBreak()
    {
        _builder.AppendLine($"    jmp {_breakLabels.Peek()}");
        _codeIsReachable = false;
    }

    private static void EmitContinue()
    {
        _builder.AppendLine($"    jmp {_continueLabels.Peek()}");
        _codeIsReachable = false;
    }

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

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

        _builder.AppendLine(endLabel);
    }

    private static void EmitReturn(BoundReturnNode @return)
    {
        if (@return.Value.HasValue)
        {
            var result = EmitUnwrap(EmitExpression(@return.Value.Value));
            _builder.AppendLine($"    ret {result}");
        }
        else
        {
            _builder.AppendLine("    ret");
        }
    }

    private static void EmitVariableDeclaration(BoundVariableDeclarationNode variableDeclaration)
    {
        var tmp = VarName();
        _builder.AppendLine($"    {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}");
        _variables.Push(new Variable(variableDeclaration.Name, new Val(tmp, variableDeclaration.Type, ValKind.Pointer)));
    }

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

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

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

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

    private static Val EmitExpression(BoundExpressionNode expression)
    {
        return expression switch
        {
            BoundAddressOfNode addressOf => EmitAddressOf(addressOf),
            BoundAnonymousFuncNode anonymousFunc => EmitAnonymousFunc(anonymousFunc),
            BoundArrayIndexAccessNode arrayIndex => EmitArrayIndexAccess(arrayIndex),
            BoundArrayInitializerNode arrayInitializer => EmitArrayInitializer(arrayInitializer),
            BoundBinaryExpressionNode binaryExpression => EmitBinaryExpression(binaryExpression),
            BoundDereferenceNode dereference => EmitDereference(dereference),
            BoundFuncCallNode funcCallExpression => EmitFuncCall(funcCallExpression),
            BoundIdentifierNode identifier => EmitIdentifier(identifier),
            BoundLiteralNode literal => EmitLiteral(literal),
            BoundStructInitializerNode structInitializer => EmitStructInitializer(structInitializer),
            BoundUnaryExpressionNode unaryExpression => EmitUnaryExpression(unaryExpression),
            BoundMemberAccessNode memberAccess => EmitMemberAccess(memberAccess),
            _ => throw new ArgumentOutOfRangeException(nameof(expression))
        };
    }

    private static Val EmitAnonymousFunc(BoundAnonymousFuncNode anonymousFunc)
    {
        var name = $"$anon_func{++_anonymousFuncIndex}";
        _anonymousFunctions.Enqueue((anonymousFunc, name));
        return new Val(name, anonymousFunc.Type, ValKind.Direct);
    }

    private static Val EmitArrayIndexAccess(BoundArrayIndexAccessNode arrayIndexAccess)
    {
        var array = EmitUnwrap(EmitExpression(arrayIndexAccess.Array));
        var index = EmitUnwrap(EmitExpression(arrayIndexAccess.Index));

        var elementType = ((NubArrayType)arrayIndexAccess.Array.Type).ElementType;

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

    private static void EmitArrayBoundsCheck(string array, string index)
    {
        var count = VarName();
        _builder.AppendLine($"    {count} =l loadl {array}");

        var isNegative = VarName();
        _builder.AppendLine($"    {isNegative} =w csltl {index}, 0");

        var isOob = VarName();
        _builder.AppendLine($"    {isOob} =w csgel {index}, {count}");

        var anyOob = VarName();
        _builder.AppendLine($"    {anyOob} =w or {isNegative}, {isOob}");

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

        _builder.AppendLine(oobLabel);
        _builder.AppendLine($"    call $nub_panic_array_oob()");

        _builder.AppendLine(notOobLabel);
    }

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

        var capacityInBytes = VarName();
        _builder.AppendLine($"    {capacityInBytes} =l mul {capacity}, {elementSize}");
        var totalSize = VarName();
        _builder.AppendLine($"    {totalSize} =l add {capacityInBytes}, 8");

        var arrayPointer = VarName();
        _builder.AppendLine($"    {arrayPointer} =l alloc8 {totalSize}");
        _builder.AppendLine($"    storel {capacity}, {arrayPointer}");

        var dataPointer = VarName();
        _builder.AppendLine($"    {dataPointer} =l add {arrayPointer}, 8");
        _builder.AppendLine($"    call $nub_memset(l {dataPointer}, w 0, l {capacityInBytes})");

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

    private static Val EmitDereference(BoundDereferenceNode dereference)
    {
        var result = EmitUnwrap(EmitExpression(dereference.Expression));
        return EmitLoad(dereference.Type, result);
    }

    private static Val EmitAddressOf(BoundAddressOfNode addressOf)
    {
        throw new NotImplementedException();
    }

    private static Val EmitBinaryExpression(BoundBinaryExpressionNode binaryExpression)
    {
        var left = EmitUnwrap(EmitExpression(binaryExpression.Left));
        var right = EmitUnwrap(EmitExpression(binaryExpression.Right));
        var outputName = VarName();
        var output = new Val(outputName, binaryExpression.Type, ValKind.Direct);

        switch (binaryExpression.Operator)
        {
            case BinaryExpressionOperator.Equal:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w ceql {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w ceqw {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w ceqw {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.NotEqual:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w cnel {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w cnew {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w cnew {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.GreaterThan:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w csgtl {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w csgtw {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w csgtw {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.GreaterThanOrEqual:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w csgel {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w csgew {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w csgew {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.LessThan:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w csltl {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w csltw {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w csltw {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.LessThanOrEqual:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =w cslel {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w cslew {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.Bool))
                {
                    _builder.AppendLine($"    {outputName} =w cslew {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.Plus:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =l add {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w add {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.Minus:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =l sub {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w sub {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.Multiply:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =l mul {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w mul {left}, {right}");
                    return output;
                }

                break;
            }
            case BinaryExpressionOperator.Divide:
            {
                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I64))
                {
                    _builder.AppendLine($"    {outputName} =l div {left}, {right}");
                    return output;
                }

                if (binaryExpression.Left.Type.Equals(NubPrimitiveType.I32))
                {
                    _builder.AppendLine($"    {outputName} =w div {left}, {right}");
                    return output;
                }

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

        throw new NotSupportedException($"Binary operator {binaryExpression.Operator} for types {binaryExpression.Left.Type} and {binaryExpression.Right.Type} not supported");
    }

    private static Val EmitIdentifier(BoundIdentifierNode identifier)
    {
        if (_definitionTable.LookupFunc(identifier.Namespace.Or(_syntaxTree.Namespace), identifier.Name).TryGetValue(out var func))
        {
            return new Val(FuncName(func), identifier.Type, ValKind.Direct);
        }

        if (!identifier.Namespace.HasValue)
        {
            return _variables.Single(v => v.Name == identifier.Name).Val;
        }

        throw new UnreachableException();
    }

    private static Val EmitLiteral(BoundLiteralNode literal)
    {
        switch (literal.Kind)
        {
            case LiteralKind.Integer:
            {
                if (literal.Type.IsFloat32)
                {
                    var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
                    var bits = BitConverter.SingleToInt32Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type.IsFloat64)
                {
                    var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
                    var bits = BitConverter.DoubleToInt64Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type.IsInteger)
                {
                    return new Val(literal.Literal, literal.Type, ValKind.Direct);
                }

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

                if (literal.Type.IsFloat32)
                {
                    var value = float.Parse(literal.Literal, CultureInfo.InvariantCulture);
                    var bits = BitConverter.SingleToInt32Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

                if (literal.Type.IsFloat64)
                {
                    var value = double.Parse(literal.Literal, CultureInfo.InvariantCulture);
                    var bits = BitConverter.DoubleToInt64Bits(value);
                    return new Val(bits.ToString(), literal.Type, ValKind.Direct);
                }

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

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

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

                break;
            }
        }

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

    private static Val EmitStructInitializer(BoundStructInitializerNode structInitializer)
    {
        var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue();

        var output = VarName();
        var size = SizeOf(structInitializer.StructType);
        _builder.AppendLine($"    {output} =l alloc8 {size}");

        foreach (var field in structDefinition.Fields)
        {
            var offset = OffsetOf(structDefinition, field.Name);

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

            Debug.Assert(valueExpression != null);

            var destination = VarName();
            _builder.AppendLine($"    {destination} =l add {output}, {offset}");
            var source = EmitUnwrap(EmitExpression(valueExpression));
            EmitCopyInto(valueExpression.Type, source, destination);
        }

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

    private static Val EmitUnaryExpression(BoundUnaryExpressionNode unaryExpression)
    {
        var operand = EmitUnwrap(EmitExpression(unaryExpression.Operand));
        var outputName = VarName();

        switch (unaryExpression.Operator)
        {
            case UnaryExpressionOperator.Negate:
            {
                switch (unaryExpression.Operand.Type)
                {
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.I64 }:
                        _builder.AppendLine($"    {outputName} =l neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }:
                        _builder.AppendLine($"    {outputName} =w neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }:
                        _builder.AppendLine($"    {outputName} =d neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }:
                        _builder.AppendLine($"    {outputName} =s neg {operand}");
                        return new Val(outputName, unaryExpression.Type, ValKind.Direct);
                }

                break;
            }
            case UnaryExpressionOperator.Invert:
            {
                switch (unaryExpression.Operand.Type)
                {
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }:
                        _builder.AppendLine($"    {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 static Val EmitMemberAccess(BoundMemberAccessNode memberAccess)
    {
        var item = EmitUnwrap(EmitExpression(memberAccess.Expression));
        var output = VarName();

        switch (memberAccess.Expression.Type)
        {
            case NubArrayType:
            {
                if (memberAccess.Member == "count")
                {
                    _builder.AppendLine($"    {output} =l loadl {item}");
                    return new Val(output, memberAccess.Type, ValKind.Direct);
                }

                break;
            }
            case NubStringType:
            {
                if (memberAccess.Member == "count")
                {
                    _builder.AppendLine($"    {output} =l call $nub_string_length(l {item})");
                    return new Val(output, memberAccess.Type, ValKind.Direct);
                }

                break;
            }
            case NubCStringType:
            {
                if (memberAccess.Member == "count")
                {
                    _builder.AppendLine($"    {output} =l call $nub_cstring_length(l {item})");
                    return new Val(output, memberAccess.Type, ValKind.Direct);
                }

                break;
            }
            case NubStructType structType:
            {
                var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
                var offset = OffsetOf(structDefinition, memberAccess.Member);

                _builder.AppendLine($"    {output} =l add {item}, {offset}");
                return new Val(output, memberAccess.Type, ValKind.Pointer);
            }
        }

        throw new UnreachableException();
    }

    private static Val EmitFuncCall(BoundFuncCallNode funcCall)
    {
        var funcType = (NubFuncType)funcCall.Expression.Type;

        var parameterStrings = new List<string>();

        foreach (var parameter in funcCall.Parameters)
        {
            var result = EmitUnwrap(EmitExpression(parameter));
            var copy = EmitCopy(parameter.Type, result);

            var qbeType = parameter.Type switch
            {
                NubArrayType => "l",
                NubPointerType => "l",
                NubPrimitiveType pointerType => pointerType.Kind switch
                {
                    PrimitiveTypeKind.I64 => "l",
                    PrimitiveTypeKind.I32 => "w",
                    PrimitiveTypeKind.I16 => "sh",
                    PrimitiveTypeKind.I8 => "sb",
                    PrimitiveTypeKind.U64 => "l",
                    PrimitiveTypeKind.U32 => "w",
                    PrimitiveTypeKind.U16 => "uh",
                    PrimitiveTypeKind.U8 => "ub",
                    PrimitiveTypeKind.F64 => "d",
                    PrimitiveTypeKind.F32 => "s",
                    PrimitiveTypeKind.Bool => "w",
                    _ => throw new ArgumentOutOfRangeException()
                },
                NubStructType structType => StructName(_definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue()),
                NubFuncType => "l",
                NubCStringType => "l",
                NubStringType => "l",
                _ => throw new NotSupportedException($"'{parameter.Type}' type cannot be used in function calls")
            };

            parameterStrings.Add($"{qbeType} {copy}");
        }

        var funcPointer = EmitUnwrap(EmitExpression(funcCall.Expression));

        if (funcType.ReturnType is not NubVoidType)
        {
            var outputName = VarName();

            _builder.AppendLine($"    {outputName} {QBEAssign(funcCall.Type)} call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(outputName, funcCall.Type, ValKind.Direct);
        }
        else
        {
            _builder.AppendLine($"    call {funcPointer}({string.Join(", ", parameterStrings)})");
            return new Val(string.Empty, funcCall.Type, ValKind.Direct);
        }
    }

    private static string EmitUnwrap(Val val)
    {
        if (val.Type.IsVoid)
        {
            throw new InvalidOperationException("Cannot unwrap temporary of void type");
        }

        switch (val.Kind)
        {
            case ValKind.Direct:
            {
                return val.Name;
            }
            case ValKind.Pointer:
            {
                if (val.Type is NubStructType)
                {
                    return val.Name;
                }

                return EmitLoad(val.Type, val.Name).Name;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }
}

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

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

internal class Variable(string name, Val val)
{
    public string Name { get; } = name;
    public Val Val { get; } = val;
}

internal class Val(string name, NubType type, ValKind kind)
{
    public string Name { get; } = name;
    public NubType Type { get; } = type;
    public ValKind Kind { get; } = kind;

    public override string ToString()
    {
        throw new InvalidOperationException();
    }
}

internal enum ValKind
{
    Pointer,
    Direct,
}