using System.Diagnostics;
using System.Globalization;
using System.Text;
using Syntax;
using Syntax.Parsing;
using Syntax.Parsing.Definitions;
using Syntax.Parsing.Expressions;
using Syntax.Parsing.Statements;
using Syntax.Tokenization;
using Syntax.Typing;

namespace Generation.QBE;

public static class QBEGenerator
{
    private static CompilationUnit _compilationUnit = null!;
    private static DefinitionTable _definitionTable = null!;

    private static StringBuilder _builder = new();
    private static List<string> _strings = [];
    private static Stack<string> _breakLabels = [];
    private static Stack<string> _continueLabels = [];
    private static Queue<(AnonymousFuncNode Func, string Name)> _anonymousFunctions = [];
    private static Stack<(string Name, string Pointer)> _variables = [];
    private static Stack<int> _variableScopes = [];
    private static int _variableIndex;
    private static int _labelIndex;
    private static int _anonymousFuncIndex;
    private static bool _codeIsReachable = true;

    public static string Generate(CompilationUnit compilationUnit, DefinitionTable definitionTable)
    {
        _compilationUnit = compilationUnit;
        _definitionTable = definitionTable;

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

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

        foreach (var funcDef in _compilationUnit.Definitions.OfType<LocalFuncDefinitionNode>())
        {
            GenerateFuncDefinition(FuncName(funcDef), funcDef.Parameters, funcDef.ReturnType, funcDef.Body, funcDef.Exported);
            _builder.AppendLine();
        }

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

        for (var i = 0; i < _strings.Count; i++)
        {
            _builder.AppendLine($"data $string{i + 1} = {{ b \"{_strings[i]}\", b 0 }}");
        }

        return _builder.ToString();
    }

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

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

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

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

    private static string QBEStore(NubType type)
    {
        return 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",
            NubFixedArrayType => "storel",
            NubFuncType => "storel",
            _ => throw new NotSupportedException($"'{type}' type cannot be used in store instructions")
        };
    }

    private static string QBELoad(NubType type)
    {
        return 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",
            NubFixedArrayType => "loadl",
            NubFuncType => "loadl",
            _ => throw new NotSupportedException($"'{type}' type cannot be used in load instructions")
        };
    }

    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",
            NubFixedArrayType => "=l",
            NubFuncType => "=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 NubFuncType:
            {
                return 8;
            }
            case NubFixedArrayType nubFixedArrayType:
            {
                return AlignmentOf(nubFixedArrayType.ElementType);
            }
            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 => 8,
                    PrimitiveTypeKind.I32 or PrimitiveTypeKind.U32 or PrimitiveTypeKind.Bool => 4,
                    PrimitiveTypeKind.I16 or PrimitiveTypeKind.U16 => 2,
                    PrimitiveTypeKind.I8 or PrimitiveTypeKind.U8 => 1,
                    PrimitiveTypeKind.F64 => 8,
                    PrimitiveTypeKind.F32 => 4,
                    _ => 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 NubFuncType:
            {
                return 8;
            }
            case NubFixedArrayType nubFixedArrayType:
            {
                return SizeOf(nubFixedArrayType.ElementType) * nubFixedArrayType.Capacity + 8;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

    private static int OffsetOf(StructDefinitionNode 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 bool IsLargeType(NubType type)
    {
        return type switch
        {
            NubArrayType => false,
            NubPointerType => false,
            NubPrimitiveType => false,
            NubStructType => true,
            NubFixedArrayType => true,
            NubFuncType => false,
            _ => throw new ArgumentOutOfRangeException(nameof(type))
        };
    }

    private static void GenerateFuncDefinition(string name, List<FuncParameter> parameters, NubType returnType, BlockNode 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()),
                NubFixedArrayType => "l",
                NubFuncType => "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()),
                NubFixedArrayType => "l",
                NubFuncType => "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<(string Name, string Pointer)> 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((parameter.Name, parameterName));
        }

        GenerateBlock(body, parameterVars);

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

        _builder.AppendLine("}");
    }

    private static void GenerateStructDefinition(StructDefinitionNode 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()),
                NubFixedArrayType fixedArrayType => $"b {SizeOf(fixedArrayType)}",
                NubFuncType => "l",
                _ => throw new NotSupportedException($"'{structDefinitionField.Type}' type cannot be used in structs")
            };
            _builder.Append(qbeType + ", ");
        }

        _builder.AppendLine("}");
    }

    private static void GenerateStatement(StatementNode statement)
    {
        switch (statement)
        {
            case ArrayIndexAssignmentNode arrayIndexAssignment:
                GenerateArrayIndexAssignment(arrayIndexAssignment);
                break;
            case BreakNode:
                GenerateBreak();
                break;
            case ContinueNode:
                GenerateContinue();
                break;
            case DereferenceAssignmentNode dereferenceAssignment:
                GenerateDereferenceAssignment(dereferenceAssignment);
                break;
            case IfNode ifStatement:
                GenerateIf(ifStatement);
                break;
            case MemberAssignmentNode memberAssignment:
                GenerateMemberAssignment(memberAssignment);
                break;
            case ReturnNode @return:
                GenerateReturn(@return);
                break;
            case StatementExpressionNode statementExpression:
                GenerateExpression(statementExpression.Expression);
                break;
            case VariableAssignmentNode variableAssignment:
                GenerateVariableAssignment(variableAssignment);
                break;
            case VariableDeclarationNode variableDeclaration:
                GenerateVariableDeclaration(variableDeclaration);
                break;
            case WhileNode whileStatement:
                GenerateWhile(whileStatement);
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(statement));
        }
    }

    private static void GenerateArrayIndexAssignment(ArrayIndexAssignmentNode arrayIndexAssignment)
    {
        var array = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Array);
        var index = GenerateExpression(arrayIndexAssignment.ArrayIndexAccess.Index);
        GenerateArrayBoundsCheck(array, index);
        var value = GenerateExpression(arrayIndexAssignment.Value);

        switch (arrayIndexAssignment.ArrayIndexAccess.Array.Type)
        {
            case NubArrayType arrayType:
            {
                var startName = VarName();
                _builder.AppendLine($"    {startName} =l add {array}, 8");

                var adjustedIndex = VarName();
                _builder.AppendLine($"    {adjustedIndex} =l mul {index}, {SizeOf(arrayType.ElementType)}");

                var pointer = VarName();
                _builder.AppendLine($"    {pointer} =l add {startName}, {adjustedIndex}");

                GenerateCopy(arrayType.ElementType, value, pointer);
                break;
            }
            case NubFixedArrayType fixedArrayType:
            {
                var startName = VarName();
                _builder.AppendLine($"    {startName} =l add {array}, 8");

                var adjustedIndex = VarName();
                _builder.AppendLine($"    {adjustedIndex} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");

                var pointer = VarName();
                _builder.AppendLine($"    {pointer} =l add {startName}, {adjustedIndex}");

                GenerateCopy(fixedArrayType.ElementType, value, pointer);
                break;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

    private static void GenerateBlock(BlockNode block, List<(string Name, string Pointer)>? 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))
        {
            GenerateStatement(statement);
        }

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

        _codeIsReachable = true;
    }

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

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

    private static void GenerateDereferenceAssignment(DereferenceAssignmentNode dereferenceAssignment)
    {
        var pointer = GenerateExpression(dereferenceAssignment.Dereference.Expression);
        var value = GenerateExpression(dereferenceAssignment.Value);
        GenerateCopy(dereferenceAssignment.Value.Type, value, pointer);
    }

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

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

        _builder.AppendLine(endLabel);
    }

    private static void GenerateMemberAssignment(MemberAssignmentNode memberAssignment)
    {
        var structType = memberAssignment.MemberAccess.Expression.Type as NubStructType;
        Debug.Assert(structType != null);

        var structDefinition = _definitionTable.LookupStruct(structType.Namespace, structType.Name).GetValue();
        var offset = OffsetOf(structDefinition, memberAssignment.MemberAccess.Member);

        var item = GenerateExpression(memberAssignment.MemberAccess.Expression);
        var pointer = VarName();

        _builder.AppendLine($"    {pointer} =l add {item}, {offset}");

        var value = GenerateExpression(memberAssignment.Value);

        GenerateCopy(memberAssignment.Value.Type, value, pointer);
    }

    private static void GenerateReturn(ReturnNode @return)
    {
        if (@return.Value.HasValue)
        {
            var result = GenerateExpression(@return.Value.Value);
            _builder.AppendLine($"    ret {result}");
        }
        else
        {
            _builder.AppendLine("    ret");
        }
    }

    private static void GenerateVariableDeclaration(VariableDeclarationNode variableDeclaration)
    {
        var type = variableDeclaration.ExplicitType.Value ?? variableDeclaration.Value.Value!.Type;
        var pointer = VarName();
        _builder.AppendLine($"    {pointer} =l alloc8 {SizeOf(type)}");

        if (variableDeclaration.Value.HasValue)
        {
            var value = GenerateExpression(variableDeclaration.Value.Value);
            GenerateCopy(variableDeclaration.Value.Value.Type, value, pointer);
        }
        else
        {
            var pointerName = VarName();
            _variables.Push((variableDeclaration.Name, pointerName));
        }

        _variables.Push((variableDeclaration.Name, pointer));
    }

    private static void GenerateVariableAssignment(VariableAssignmentNode variableAssignment)
    {
        var value = GenerateExpression(variableAssignment.Value);
        var variable = _variables.Single(x => x.Name == variableAssignment.Identifier.Name);
        GenerateCopy(variableAssignment.Value.Type, value, variable.Pointer);
    }

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

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

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

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

    private static string GenerateExpression(ExpressionNode expression)
    {
        return expression switch
        {
            AddressOfNode addressOf => GenerateAddressOf(addressOf),
            AnonymousFuncNode anonymousFunc => GenerateAnonymousFunc(anonymousFunc),
            ArrayIndexAccessNode arrayIndex => GenerateArrayAccessIndex(arrayIndex),
            ArrayInitializerNode arrayInitializer => GenerateArrayInitializer(arrayInitializer),
            BinaryExpressionNode binaryExpression => GenerateBinaryExpression(binaryExpression),
            DereferenceNode dereference => GenerateDereference(dereference),
            FixedArrayInitializerNode fixedArrayInitializer => GenerateFixedArrayInitializer(fixedArrayInitializer),
            FuncCallNode funcCallExpression => GenerateFuncCall(funcCallExpression),
            IdentifierNode identifier => GenerateIdentifier(identifier),
            LiteralNode literal => GenerateLiteral(literal),
            StructInitializerNode structInitializer => GenerateStructInitializer(structInitializer),
            UnaryExpressionNode unaryExpression => GenerateUnaryExpression(unaryExpression),
            MemberAccessNode memberAccess => GenerateMemberAccess(memberAccess),
            _ => throw new ArgumentOutOfRangeException(nameof(expression))
        };
    }

    private static string GenerateAnonymousFunc(AnonymousFuncNode anonymousFunc)
    {
        var name = $"$anon_func{++_anonymousFuncIndex}";
        _anonymousFunctions.Enqueue((anonymousFunc, name));
        var pointer = VarName();
        _builder.AppendLine($"    {pointer} =l alloc8 8");
        _builder.AppendLine($"    storel {name}, {pointer}");
        return pointer;
    }

    private static string GenerateArrayIndexPointer(ArrayIndexAccessNode arrayIndexAccess)
    {
        var array = GenerateExpression(arrayIndexAccess.Array);
        var index = GenerateExpression(arrayIndexAccess.Index);
        GenerateArrayBoundsCheck(array, index);

        switch (arrayIndexAccess.Array.Type)
        {
            case NubArrayType arrayType:
            {
                var firstItemPointerName = VarName();
                _builder.AppendLine($"    {firstItemPointerName} =l add {array}, 8");
                var offsetPointerName = VarName();
                _builder.AppendLine($"    {offsetPointerName} =l mul {index}, {SizeOf(arrayType.ElementType)}");
                var resultPointerName = VarName();
                _builder.AppendLine($"    {resultPointerName} =l add {firstItemPointerName}, {offsetPointerName}");
                return resultPointerName;
            }
            case NubFixedArrayType fixedArrayType:
            {
                var firstItemPointerName = VarName();
                _builder.AppendLine($"    {firstItemPointerName} =l add {array}, 8");
                var offsetPointerName = VarName();
                _builder.AppendLine($"    {offsetPointerName} =l mul {index}, {SizeOf(fixedArrayType.ElementType)}");
                var resultPointerName = VarName();
                _builder.AppendLine($"    {resultPointerName} =l add {firstItemPointerName}, {offsetPointerName}");
                return resultPointerName;
            }
            default:
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

    private static string GenerateArrayAccessIndex(ArrayIndexAccessNode arrayIndexAccess)
    {
        var pointerName = GenerateArrayIndexPointer(arrayIndexAccess);

        if (IsLargeType(arrayIndexAccess.Type))
        {
            return pointerName;
        }
        else
        {
            var outputName = VarName();
            _builder.AppendLine($"    {outputName} {QBEAssign(arrayIndexAccess.Type)} {QBELoad(arrayIndexAccess.Type)} {pointerName}");
            return outputName;
        }
    }

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

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

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

        var anyOobName = VarName();
        _builder.AppendLine($"    {anyOobName} =w or {isNegativeName}, {isOobName}");

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

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

        _builder.AppendLine(notOobLabel);
    }

    private static string GenerateArrayInitializer(ArrayInitializerNode arrayInitializer)
    {
        var capacity = GenerateExpression(arrayInitializer.Capacity);
        var elementSize = SizeOf(arrayInitializer.ElementType);
        var capacityInBytes = VarName();
        _builder.AppendLine($"    {capacityInBytes} =l mul {capacity}, {elementSize}");
        var totalArraySize = VarName();
        _builder.AppendLine($"    {totalArraySize} =l add {capacityInBytes}, 8");
        var outputName = VarName();
        _builder.AppendLine($"    {outputName} =l alloc8 {totalArraySize}");
        _builder.AppendLine($"    storel {capacity}, {outputName}");

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

        return outputName;
    }

    private static string GenerateDereference(DereferenceNode dereference)
    {
        var result = GenerateExpression(dereference.Expression);
        var outputName = VarName();
        _builder.AppendLine($"    {outputName} {QBEAssign(dereference.Type)} {QBELoad(dereference.Type)} {result}");
        return outputName;
    }

    private static string GenerateAddressOf(AddressOfNode addressOf)
    {
        switch (addressOf.Expression)
        {
            case ArrayIndexAccessNode arrayIndexAccess:
                return GenerateArrayIndexPointer(arrayIndexAccess);
            case DereferenceNode dereference:
                return GenerateExpression(dereference.Expression);
            case IdentifierNode identifier:
                if (identifier.Namespace.HasValue)
                {
                    throw new NotSupportedException("There is nothing to address in another namespace");
                }

                return _variables.Single(x => x.Name == identifier.Name).Pointer;
            case MemberAccessNode memberAccess:
                return GenerateMemberAccessPointer(memberAccess);
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    private static string GenerateBinaryExpression(BinaryExpressionNode binaryExpression)
    {
        var left = GenerateExpression(binaryExpression.Left);
        var right = GenerateExpression(binaryExpression.Right);
        var outputName = VarName();

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

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

                // if (binaryExpression.Left.Type.Equals(NubPrimitiveType.String))
                // {
                //     _builder.AppendLine($"    {outputName} =w call $nub_strcmp(l {left}, l {right})");
                //     return outputName;
                // }

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

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

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

                // if (binaryExpression.Left.Type.Equals(NubPrimitiveType.String))
                // {
                //     _builder.AppendLine($"    {outputName} =w call $nub_strcmp(l {left}, l {right})");
                //     _builder.AppendLine($"    {outputName} =w xor {outputName}, 1");
                //     return outputName;
                // }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                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 string GenerateIdentifier(IdentifierNode identifier)
    {
        if (_definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func))
        {
            var pointer = VarName();
            _builder.AppendLine($"    {pointer} =l alloc8 8");
            _builder.AppendLine($"    storel {FuncName(func)}, {pointer}");
            return pointer;
        }

        if (!identifier.Namespace.HasValue)
        {
            var variable = _variables.Single(v => v.Name == identifier.Name);
            return GenerateDereference(identifier.Type, variable.Pointer);
        }

        throw new UnreachableException();
    }

    private static string GenerateLiteral(LiteralNode literal)
    {
        if (literal.Type.IsInteger)
        {
            switch (literal.Kind)
            {
                case LiteralKind.Integer:
                    return literal.Literal;
                case LiteralKind.Float:
                    return literal.Literal.Split(".").First();
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

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

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

        switch (literal.Kind)
        {
            case LiteralKind.String:
                _strings.Add(literal.Literal);
                return $"$string{_strings.Count}";
            case LiteralKind.Bool:
                return bool.Parse(literal.Literal) ? "1" : "0";
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    private static string GenerateStructInitializer(StructInitializerNode structInitializer)
    {
        var structDefinition = _definitionTable.LookupStruct(structInitializer.StructType.Namespace, structInitializer.StructType.Name).GetValue();

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

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

            if (structInitializer.Initializers.TryGetValue(field.Name, out var fieldValue))
            {
                var value = GenerateExpression(fieldValue);
                var pointer = VarName();
                _builder.AppendLine($"    {pointer} =l add {structVar}, {offset}");
                GenerateCopy(field.Type, value, pointer);
            }
            else if (field.Value.HasValue)
            {
                var value = GenerateExpression(field.Value.Value);
                var pointer = VarName();
                _builder.AppendLine($"    {pointer} =l add {structVar}, {offset}");
                GenerateCopy(field.Type, value, pointer);
            }
            else
            {
                Debug.Assert(false);
            }
        }

        return structVar;
    }

    private static string GenerateUnaryExpression(UnaryExpressionNode unaryExpression)
    {
        var operand = GenerateExpression(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 outputName;
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.I32 or PrimitiveTypeKind.I16 or PrimitiveTypeKind.I8 }:
                        _builder.AppendLine($"    {outputName} =w neg {operand}");
                        return outputName;
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.F64 }:
                        _builder.AppendLine($"    {outputName} =d neg {operand}");
                        return outputName;
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.F32 }:
                        _builder.AppendLine($"    {outputName} =s neg {operand}");
                        return outputName;
                }

                break;
            }
            case UnaryExpressionOperator.Invert:
            {
                switch (unaryExpression.Operand.Type)
                {
                    case NubPrimitiveType { Kind: PrimitiveTypeKind.Bool }:
                        _builder.AppendLine($"    {outputName} =w xor {operand}, 1");
                        return outputName;
                }

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

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

    private static string GenerateMemberAccessPointer(MemberAccessNode memberAccess)
    {
        var item = GenerateExpression(memberAccess.Expression);
        switch (memberAccess.Expression.Type)
        {
            case NubArrayType:
            {
                if (memberAccess.Member == "count")
                {
                    return item;
                }

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

                var offsetName = VarName();
                _builder.AppendLine($"    {offsetName} =l add {item}, {offset}");
                return offsetName;
            }
            default:
            {
                throw new ArgumentOutOfRangeException(nameof(memberAccess.Expression.Type));
            }
        }
    }

    private static string GenerateMemberAccess(MemberAccessNode memberAccess)
    {
        var pointer = GenerateMemberAccessPointer(memberAccess);

        if (IsLargeType(memberAccess.Type))
        {
            return pointer;
        }
        else
        {
            var outputName = VarName();
            _builder.AppendLine($"    {outputName} {QBEAssign(memberAccess.Type)} {QBELoad(memberAccess.Type)} {pointer}");
            return outputName;
        }
    }

    private static string GenerateFixedArrayInitializer(FixedArrayInitializerNode fixedArrayInitializer)
    {
        var totalSize = SizeOf(fixedArrayInitializer.Type);
        var outputName = VarName();
        _builder.AppendLine($"    {outputName} =l alloc8 {totalSize}");

        _builder.AppendLine($"    storel {fixedArrayInitializer.Capacity}, {outputName}");

        var dataPtr = VarName();
        _builder.AppendLine($"    {dataPtr} =l add {outputName}, 8");

        var dataSize = totalSize - 8;
        _builder.AppendLine($"    call $nub_memset(l {dataPtr}, w 0, l {dataSize})");

        return outputName;
    }

    private static string GenerateFuncCall(FuncCallNode funcCall)
    {
        var funcType = (NubFuncType)funcCall.Expression.Type;

        var parameterStrings = new List<string>();

        for (var i = 0; i < funcCall.Parameters.Count; i++)
        {
            var parameter = funcCall.Parameters[i];
            var result = GenerateExpression(parameter);

            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()),
                NubFixedArrayType => "l",
                NubFuncType => "l",
                _ => throw new NotSupportedException($"'{parameter.Type}' type cannot be used in function calls")
            };
            parameterStrings.Add($"{qbeType} {result}");
        }

        string funcTarget;
        if (funcCall.Expression is IdentifierNode identifier && _definitionTable.LookupFunc(identifier.Namespace.Or(_compilationUnit.Namespace), identifier.Name).TryGetValue(out var func))
        {
            funcTarget = FuncName(func);
        }
        else
        {
            var funcPointerPointer = GenerateExpression(funcCall.Expression);
            var funcPointer = VarName();
            _builder.AppendLine($"    {funcPointer} =l loadl {funcPointerPointer}");
            funcTarget = funcPointer;
        }

        if (funcType.ReturnType is not NubVoidType)
        {
            var outputName = VarName();
            _builder.AppendLine($"    {outputName} {QBEAssign(funcCall.Type)} call {funcTarget}({string.Join(", ", parameterStrings)})");
            return outputName;
        }
        else
        {
            _builder.AppendLine($"    call {funcTarget}({string.Join(", ", parameterStrings)})");
            return "fuck";
        }
    }

    private static void GenerateCopy(NubType type, string value, string destinationPointer)
    {
        if (IsLargeType(type))
        {
            _builder.AppendLine($"    blit {value}, {destinationPointer}, {SizeOf(type)}");
        }
        else
        {
            _builder.AppendLine($"    {QBEStore(type)} {value}, {destinationPointer}");
        }
    }

    private static string GenerateDereference(NubType type, string pointer)
    {
        if (IsLargeType(type))
        {
            return pointer;
        }
        else
        {
            var result = VarName();
            _builder.AppendLine($"    {result} {QBEAssign(type)} {QBELoad(type)} {pointer}");
            return result;
        }
    }
}