using System;
using System.Collections.Generic;

namespace Amogulator.Suslang;

public enum TokenType {
    Eof,
    Invalid,
    Id,
    Int,
    Hex,
    Decimal,
    String,
    True,
    False,
    LParen,
    RParen,
    Plus,
    Minus,
    Asterisk,
    Slash,
    Percent,
    Dot,
}

public struct Position {
    public int index;
    public int line, col;
}

public struct Token {
    public TokenType type;
    public Position position;
    public int length;
}

public class Lexer {
    private int i = 0;
    private string text;
    private int line = 1;
    private int col = 1;

    public Lexer(string text) {
        this.text = text;
    }

    public Token next() {
        if (done()) {
            return token(TokenType.Eof, position());
        } else if (" \t\r\n".Contains(current())) {
            while (!done() && " \t\r\n".Contains(current()))
                step();
            return next();
        } else if ("123456789".Contains(current())) {
            return intToken();
        } else if ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".Contains(current())) {
            return idToken();
        } else {
            return staticToken();
        }
    }

    private Token intToken() {
        var start = position();
        step();
        while (!done() && "1234567890".Contains(current()))
            step();
        return token(TokenType.Int, start);
    }

    private Token idToken() {
        var start = position();
        step();
        while (!done() && "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".Contains(current()))
            step();
        return this.text.Substring(start.index, this.i - start.index) switch {
            "false" => token(TokenType.False, start),
            "true" => token(TokenType.True, start),
            _ => token(TokenType.Id, start),
        };
    }

    private Token staticToken() {
        var start = position();
        switch (current()) {
            case '0':
                return zeroToken();
            case '.':
                return dotToken();
            case '(':
                step();
                return token(TokenType.LParen, start);
            case ')':
                step();
                return token(TokenType.RParen, start);
            case '+':
                step();
                return token(TokenType.Plus, start);
            case '-':
                step();
                return token(TokenType.Minus, start);
            case '*':
                step();
                return token(TokenType.Asterisk, start);
            case '/':
                step();
                return token(TokenType.Slash, start);
            case '%':
                step();
                return token(TokenType.Percent, start);
            default:
                step();
                return token(TokenType.Invalid, start);
        }
    }

    private Token zeroToken() {
        var start = position();
        step();
        if (!done() && (current() == 'x' || current() == 'X')) {
            while (!done() && "1234567890abcdefABCDEF".Contains(current()))
                step();
            return token(TokenType.Hex, start);
        } else {
            while (!done() && "1234567890".Contains(current()))
                step();
            return token(TokenType.Int, start);
        }
    }

    private Token dotToken() {
        var start = position();
        step();
        if (!done() && "1234567890".Contains(current())) {
            while (!done() && "1234567890".Contains(current()))
                step();
            return token(TokenType.Decimal, start);
        } else {
            return token(TokenType.Dot, start);
        }
    }

    private Token token(TokenType type, Position start) => new Token() {
        type = type,
        position = start,
        length = this.i - start.index,
    };

    private Position position() => new Position() {
        index = this.i,
        line = this.line,
        col = this.col,
    };

    private char current() => this.text[this.i];
    private bool done() => this.i >= this.text.Length;

    private void step() {
        this.i += 1;
        if (!done()) {
            if (current() == '\n') {
                this.line += 1;
                this.col = 1;
            } else {
                this.col += 1;
            }
        }
    }
}

public interface Expr {
    string astString(int depth);
}

public class ErrorExpr : Expr {
    public Position position;
    public string message;

    public string astString(int depth) =>
        $"ErrorExpr {{ {this.position.line}:{this.position.col} \"{this.message}\" }}";
}

public class IdExpr : Expr {
    public string value;

    public string astString(int depth) =>
        $"IdExpr {{ \"{this.value}\" }}";
}

public class IntExpr : Expr {
    public int value;

    public string astString(int depth) =>
        $"IntExpr {{ {this.value} }}";
}

public class FloatExpr : Expr {
    public double value;

    public string astString(int depth) =>
        $"FloatExpr {{ {this.value} }}";
}

public class StringExpr : Expr {
    public string value;

    public string astString(int depth) =>
        $"FloatExpr {{ \"{this.value}\" }}";
}

public class BoolExpr : Expr {
    public bool value;

    public string astString(int depth) =>
        $"BoolExpr {{ {this.value} }}";
}

public enum UnaryType {
    Not,
    Negate,
}

public class UnaryExpr : Expr {
    public UnaryType type;
    public Expr value;

    public string astString(int depth) =>
        $"UnaryExpr {{\n{new string(' ', depth + 1)}type: "
        + $"{this.type},\n{new string(' ', depth + 1)}value: "
        + $"{this.value.astString(depth + 1)}\n{new String(' ', depth)}}}";
}

public enum BinaryType {
    Add,
    Subtract,
    Multiply,
    Divide,
    Modulo,
}

public class BinaryExpr : Expr {
    public BinaryType type;
    public Expr left, right;

    public string astString(int depth) =>
        $"BinaryExpr {{\n{new String(' ', depth + 1)}type: "
        + $"{this.type.ToString()},\n{new String(' ', depth + 1)}left: "
        + $"{this.left.astString(depth + 1)},\n{new String(' ', depth + 1)}right: "
        + $"{this.right.astString(depth + 1)},\n{new String(' ', depth)}}}";
}

public class Parser {
    private string text;
    private Lexer lexer;
    private Token currentToken;

    public Parser(string text, Lexer lexer) {
        this.text = text;
        this.lexer = lexer;
        this.currentToken = this.lexer.next();
    }

    public Expr parseExpr() {
        return parsePrec11();
    }

    public Expr parsePrec11() {
        var left = parsePrec12();
        if (!done() && current().type == TokenType.Plus) {
            step();
            var right = parsePrec11();
            return new BinaryExpr() {
                type = BinaryType.Add,
                left = left,
                right = right,
            };
        } else if (!done() && current().type == TokenType.Minus) {
            step();
            var right = parsePrec11();
            return new BinaryExpr() {
                type = BinaryType.Subtract,
                left = left,
                right = right,
            };
        } else {
            return left;
        }
    }

    public Expr parsePrec12() {
        var left = parsePrec13();
        if (!done() && current().type == TokenType.Asterisk) {
            step();
            var right = parsePrec12();
            return new BinaryExpr() {
                type = BinaryType.Multiply,
                left = left,
                right = right,
            };
        } else if (!done() && current().type == TokenType.Slash) {
            step();
            var right = parsePrec12();
            return new BinaryExpr() {
                type = BinaryType.Divide,
                left = left,
                right = right,
            };
        } else if (!done() && current().type == TokenType.Percent) {
            step();
            var right = parsePrec12();
            return new BinaryExpr() {
                type = BinaryType.Modulo,
                left = left,
                right = right,
            };
        } else {
            return left;
        }
    }

    public Expr parsePrec13() {
        return parsePrec18();
    }

    public Expr parsePrec18() {
        if (!done() && current().type == TokenType.LParen) {
            step();
            var expr = parseExpr();
            if (done() || current().type != TokenType.RParen) {
                var pos = position();
                step();
                return new ErrorExpr() {
                    position = pos,
                    message = "expected ')'"
                };
            }
            step();
            return expr;
        } else {
            return parseOperand();
        }
    }

    public Expr parseOperand() {
        var start = position();
        if (done()) {
            step();
            return new ErrorExpr() {
                position = start,
                message = "expected value, got Eof",
            };
        } else if (current().type == TokenType.Int) {
            var intToken = current();
            step();
            if (!done() && current().type == TokenType.Decimal) {
                var decimalToken = current();
                step();
                return new FloatExpr() {
                    value = double.Parse(this.text.Substring(start.index, intToken.length + decimalToken.length).Replace(".", ",")),
                };
            } else {
                return new IntExpr() {
                    value = int.Parse(this.text.Substring(start.index, intToken.length)),
                };
            }
        } else if (current().type == TokenType.Decimal) {
            var decimalToken = current();
            step();
            return new FloatExpr() {
                value = double.Parse("0" + this.text.Substring(start.index, decimalToken.length).Replace(".", ",")),
            };
        } else if (current().type == TokenType.String) {
            var stringToken = current();
            step();
            return new StringExpr() {
                value = this.text.Substring(start.index, stringToken.length),
            };
        } else if (current().type == TokenType.False) {
            step();
            return new BoolExpr() {
                value = false,
            };
        } else if (current().type == TokenType.True) {
            step();
            return new BoolExpr() {
                value = true,
            };
        } else {
            step();
            return new ErrorExpr() {
                position = start,
                message = "expected value",
            };
        }
    }

    private Position position() => current().position;
    private Token current() => this.currentToken;
    private bool done() => this.currentToken.type == TokenType.Eof;

    private void step() {
        this.currentToken = this.lexer.next();
    }
}

public interface Operation { }

public class PushIntOperation : Operation {
    public int value;
}

public class PushFloatOperation : Operation {
    public double value;
}

public class PushStringOperation : Operation {
    public string value;
}

public class PushBoolOperation : Operation {
    public bool value;
}

public class AddIntOperation : Operation { }
public class SubtractIntOperation : Operation { }
public class MultiplyIntOperation : Operation { }
public class DivideIntOperation : Operation { }
public class ModuloIntOperation : Operation { }
public class AddFloatOperation : Operation { }
public class SubtractFloatOperation : Operation { }
public class MultiplyFloatOperation : Operation { }
public class DivideFloatOperation : Operation { }
public class ModuloFloatOperation : Operation { }

public class Compiler {
    private List<Operation> operations = new();

    public List<Operation> result() => this.operations;

    public string compileExpr(Expr expr) {
        switch (expr) {
            case IntExpr:
                return compileIntExpr((IntExpr) expr);
                break;
            case FloatExpr:
                return compileFloatExpr((FloatExpr) expr);
                break;
            case StringExpr:
                return compileStringExpr((StringExpr) expr);
                break;
            case BoolExpr:
                return compileBoolExpr((BoolExpr) expr);
                break;
            case UnaryExpr:
                return compileUnaryExpr((UnaryExpr) expr);
                break;
            case BinaryExpr:
                return compileBinaryExpr((BinaryExpr) expr);
                break;
            default:
                throw new NotImplementedException();
        };
    }

    public string compileIntExpr(IntExpr expr) {
        this.operations.Add(new PushIntOperation() { value = expr.value });
        return "int";
    }

    public string compileFloatExpr(FloatExpr expr) {
        this.operations.Add(new PushFloatOperation() { value = expr.value });
        return "float";
    }

    public string compileStringExpr(StringExpr expr) {
        this.operations.Add(new PushStringOperation() { value = expr.value });
        return "string";
    }

    public string compileBoolExpr(BoolExpr expr) {
        this.operations.Add(new PushBoolOperation() { value = expr.value });
        return "bool";
    }

    public string compileUnaryExpr(UnaryExpr expr) {
        throw new NotImplementedException();
    }

    public string compileBinaryExpr(BinaryExpr expr) {
        var leftType = compileExpr(expr.left);
        var rightType = compileExpr(expr.right);
        if ((leftType, rightType) == ("int", "int")) {
            this.operations.Add(expr.type switch {
                BinaryType.Add => new AddIntOperation(),
                BinaryType.Subtract => new SubtractIntOperation(),
                BinaryType.Multiply => new MultiplyIntOperation(),
                BinaryType.Divide => new DivideIntOperation(),
                BinaryType.Modulo => new ModuloIntOperation(),
            });
            return "int";
        } else if ((leftType, rightType) == ("int", "int")) {
            this.operations.Add(expr.type switch {
                BinaryType.Add => new AddFloatOperation(),
                BinaryType.Subtract => new SubtractFloatOperation(),
                BinaryType.Multiply => new MultiplyFloatOperation(),
                BinaryType.Divide => new DivideFloatOperation(),
                BinaryType.Modulo => new ModuloFloatOperation(),
            });
            return "float";
        } else {
            throw new Exception("type mismatch");
        }
    }
}

public interface Value { }

public class IntValue : Value { public int value; }
public class FloatValue : Value { public double value; }

public class VM {
    private int pc = 0;
    private List<Operation> program;
    public Stack<Value> stack = new();

    public VM(List<Operation> program) {
        this.program = program;
    }

    public void evaluate() {
        while (this.pc < this.program.Count) {
            switch (this.program[this.pc]) {
                case PushIntOperation op:
                    this.stack.Push(new IntValue() { value = op.value });
                    break;
                case PushFloatOperation op:
                    this.stack.Push(new FloatValue() { value = op.value });
                    break;
                case AddIntOperation:
                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value + ((IntValue) this.stack.Pop()).value });
                    break;
                case SubtractIntOperation:
                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value - ((IntValue) this.stack.Pop()).value });
                    break;
                case MultiplyIntOperation:
                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value * ((IntValue) this.stack.Pop()).value });
                    break;
                case DivideIntOperation:
                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value / ((IntValue) this.stack.Pop()).value });
                    break;
                case ModuloIntOperation:
                    this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value % ((IntValue) this.stack.Pop()).value });
                    break;
                case AddFloatOperation:
                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value + ((FloatValue) this.stack.Pop()).value });
                    break;
                case SubtractFloatOperation:
                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value - ((FloatValue) this.stack.Pop()).value });
                    break;
                case MultiplyFloatOperation:
                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value * ((FloatValue) this.stack.Pop()).value });
                    break;
                case DivideFloatOperation:
                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value / ((FloatValue) this.stack.Pop()).value });
                    break;
                case ModuloFloatOperation:
                    this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value % ((FloatValue) this.stack.Pop()).value });
                    break;
                default:
                    break;
            }
            this.pc += 1;
        }
    }
}