#include <iostream>
#include <utility>
#include <vector>
#include <optional>
#include <variant>
#include <cctype>
#include <complex>
#include <sstream>
#include <map>
#include "../libs/linenoise.hpp"

enum class ValueTypes {
    Identifier, Int, Double, String, List, Nil
};

enum class ParserErrorType {
    UnexpectedEndOfInput,
    UnexpectedToken,
    MissingOpenParen,
    MissingCloseParen,
    UnexpectedTopLevelToken
};

enum class InterpreterErrorType {
    UnknownInstruction,
    UnexpectedToken,
    IncorrectTokenType,
    MathError,
    UnknownEnvironment
};

class InterpretingError : public std::exception {
    std::string message;
    InterpreterErrorType errorType;
    public:
    explicit InterpretingError(InterpreterErrorType errorType) : errorType(errorType) {
        std::stringstream oss;

        oss << "Interpreting error: ";
        switch (errorType) {
            case InterpreterErrorType::UnexpectedToken:
                oss << "Unexpected token";
                break;
            case InterpreterErrorType::UnknownInstruction:
                oss << "Unknown instruction";
                break;
            case InterpreterErrorType::IncorrectTokenType:
                oss << "Incorrect token type";
                break;
            case InterpreterErrorType::MathError:
                oss << "Math error";
                break;
            case InterpreterErrorType::UnknownEnvironment:
                oss << "Unknown environment";
                break;
        }
        message = oss.str();
    }

    [[nodiscard]] const char* what() const noexcept override {
        return message.c_str();
    }
};

class ParsingError : public std::exception {
    std::string message;
    ParserErrorType errorType;
    int position;
    std::string sourceCode;

public:
    ParsingError(ParserErrorType type, int pos, std::string  source = "")
        : errorType(type), position(pos), sourceCode(std::move(source)) {
        std::ostringstream oss;
        oss << "Parsing error at position " << pos << ": ";

        switch (type) {
            case ParserErrorType::UnexpectedEndOfInput:
                oss << "Unexpected end of input";
                break;
            case ParserErrorType::UnexpectedToken:
                oss << "Unexpected token";
                break;
            case ParserErrorType::MissingOpenParen:
                oss << "Expected '(' at start of expression";
                break;
            case ParserErrorType::MissingCloseParen:
                oss << "Missing closing ')'";
                break;
            case ParserErrorType::UnexpectedTopLevelToken:
                oss << "Unexpected token at top level (expected '(')";
                break;
        }

        message = oss.str();
    }

    [[nodiscard]] const char* what() const noexcept override {
        return message.c_str();
    }

    [[nodiscard]] ParserErrorType getErrorType() const { return errorType; }
    [[nodiscard]] int getPosition() const { return position; }
    [[nodiscard]] const std::string& getSourceCode() const { return sourceCode; }
};

class Value {
    std::variant<int, double, std::string, void*, std::vector<Value>> value;
    public:
    ValueTypes type;
    std::optional<int> getInt() {
        if (std::holds_alternative<int>(value)) {
            return std::get<int>(value);
        }
        return {};
    }
    std::optional<double> getDouble() {
        if (std::holds_alternative<double>(value)) {
            return std::get<double>(value);
        }
        return {};
    }
    std::optional<std::string> getString() {
        if (std::holds_alternative<std::string>(value)) {
            return std::get<std::string>(value);
        }
        return {};
    }
    std::optional<std::vector<Value>> getList() {
        if (std::holds_alternative<std::vector<Value>>(value)) {
            return std::get<std::vector<Value>>(value);
        }
        return {};
    }
    void print() {
        switch (type) {
            case ValueTypes::String: {
                std::cout << getString().value();
                break;
            }
            case ValueTypes::Int: {
                std::cout << getInt().value();
                break;
            }
            case ValueTypes::Double: {
                std::cout << getDouble().value();
                break;
            }
            case ValueTypes::List: {
                auto list = getList().value();
                bool first = true;
                for (auto& listElement : list) {
                    if (!first) {
                        std::cout << ", ";
                    } else {
                        first = false;
                    }
                    listElement.print();
                }
            }
            case ValueTypes::Nil: {
                std::cout << "\033[2;3;96m" << "nil" << "\033[0m";
            }
        }

    }

    bool operator==(Value &otherValue) {
        if (type != otherValue.type) {
            return false;
        }
        switch (type) {
            case ValueTypes::String: {
                if (getString() == otherValue.getString()) {
                    return true;
                }
                return false;
            }
            case ValueTypes::Int: {
                if (getInt() == otherValue.getInt()) {
                    return true;
                }
                return false;
            }
            case ValueTypes::Double: {
                if (getDouble() == otherValue.getDouble()) {
                    return true;
                }
                return false;
            }
            case ValueTypes::List: {
                auto list = getList().value();
                auto compareList = otherValue.getList().value();
                if (list.size() != compareList.size()) {
                    return false;
                }
                for (int i = 0; i < list.size(); i++) {
                    if (list[i] == compareList[i]) {
                        return true;
                    }
                    return false;
                }
                return true;
            }
            default: return false;
        }
    }

    explicit Value() : value(nullptr), type(ValueTypes::Nil) {}
    explicit Value(int in) : value(in), type(ValueTypes::Int) {}
    explicit Value(double in) : value(in), type(ValueTypes::Double) {}
    explicit Value(std::string in) : value(in), type(ValueTypes::String) {}
    explicit Value(std::vector<Value> in) : value(in), type(ValueTypes::List) {}
    Value(std::string in, bool isIdentifier) : value(in), type(isIdentifier ? ValueTypes::Identifier : ValueTypes::String) {}
};

class Instruction {
    public:
    std::string instruction;
    std::vector<std::variant<Instruction, Value>> args;
    Instruction(std::string instruction, std::vector<std::variant<Instruction, Value>> args) : instruction(std::move(instruction)), args(std::move(args)) {}
    Instruction() = default;
};

class Parser {
    std::string input;
    std::vector<std::string> split;
    int currentChar = -1;
    int current = -1;

    std::optional<char> consumeChar() {
        currentChar++;
        if (currentChar >= input.size()) {
            return {};
        }
        return input[currentChar];
    }

    std::optional<std::string> consume() {
        current++;
        if (current >= split.size()) {
            return {};
        }
        return split[current];
    }

    [[nodiscard]] std::optional<std::string> peek() const {
        if (current + 1 >= split.size()) {
            return {};
        }
        return split[current + 1];
    }

    // Helper to detect value type
    static Value parseValue(const std::string& token) {
        // If it's nil, just return nil
        if (token == "nil") {
            return Value();
        }

        // Check if it's a string literal
        if (token.front() == '"' && token.back() == '"') {
            return Value(token.substr(1, token.length() - 2));
        }

        // Try to parse as integer
        bool isInt = true;
        bool isDouble = false;
        for (size_t i = 0; i < token.length(); i++) {
            char c = token[i];
            if (i == 0 && c == '-') continue; // Allow negative sign
            if (c == '.') {
                if (isDouble) { // Second dot
                    isInt = false;
                    break;
                }
                isDouble = true;
                isInt = false;
            } else if (!std::isdigit(c)) {
                isInt = false;
                isDouble = false;
                break;
            }
        }

        if (isInt) {
            return Value(std::stoi(token));
        }
        if (isDouble) {
            return Value(std::stod(token));
        }

        // If it isn't any value, return an identifier
        return {token, true};
    }

    // Recursive parser for expressions
    Instruction parseExpression() {
        auto topt = consume();
        if (!topt) {
            throw ParsingError(ParserErrorType::UnexpectedEndOfInput, current, input);
        }

        std::string token = topt.value();
        if (token != "(") {
            throw ParsingError(ParserErrorType::MissingOpenParen, current, input);
        }

        topt = consume();
        if (!topt) {
            throw ParsingError(ParserErrorType::UnexpectedEndOfInput, current, input);
        }

        std::string instruction = topt.value();
        std::vector<std::variant<Instruction, Value>> args;

        while (true) {
            topt = peek();
            if (!topt) {
                throw ParsingError(ParserErrorType::MissingCloseParen, current, input);
            }

            token = topt.value();

            if (token == ")") {
                consume();
                break;
            } else if (token == "(") {
                args.emplace_back(parseExpression());
            } else {
                consume();
                args.emplace_back(parseValue(token));
            }
        }

        return {instruction, args};
    }

    public:
    std::vector<Instruction> instructions;

    explicit Parser(std::string in) : input(std::move(in)) {
        // Lexer logic
        std::string buf;
        bool inString = false;
        while (auto copt = consumeChar()) {
            char c = copt.value();
            if (c != '"' && inString) {
                buf.push_back(c);
                continue;
            }
            switch (c) {
                case '(': case ')': {
                    if (!buf.empty()) {
                        split.push_back(buf);
                        buf.clear();
                    }
                    split.emplace_back(1, c);
                    break;
                }
                case ' ': case '\n':
                    if (!buf.empty()) {
                        split.push_back(buf);
                        buf.clear();
                    }
                    break;
                case '"': {
                    inString = !inString;
                    buf.push_back('"');
                    if (!inString) {
                        split.push_back(buf);
                        buf.clear();
                    }
                    break;
                }
                default: {
                    buf.push_back(c);
                }
            }
        }

        // Parser logic - parse all top-level expressions
        while (peek()) {
            auto token = peek().value();
            if (token == "(") {
                instructions.push_back(parseExpression());
            } else {
                throw ParsingError(ParserErrorType::UnexpectedTopLevelToken, current + 1, input);
            }
        }
    }
    Parser() = default;
};

class Interpreter {
    public:
    std::vector<Instruction> instructions = {};
    std::map<std::string, Value> environment = {{"pippleVersion", Value("0.0.1")}};

    Value interpretInstruction(Instruction& instruction) {
        // Preprocess identifiers
        for (auto& arg : instruction.args) {
            if (std::holds_alternative<Value>(arg) && instruction.instruction != "let" && instruction.instruction != "set") {
                if (std::get<Value>(arg).type == ValueTypes::Identifier) {
                    std::string id = std::get<Value>(arg).getString().value();
                    if (!environment.contains(id)) {
                        throw InterpretingError(InterpreterErrorType::UnknownEnvironment);
                    }
                    arg = environment[id];
                }
            }
        }
        // Instructions at the top of this function require input to not be preprocessed
        if (instruction.instruction == "if") {
            if (instruction.args.size() < 2) {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }
            bool toContinue = true;
            if (std::holds_alternative<Instruction>(instruction.args[0])) {
                toContinue = interpretInstruction(std::get<Instruction>(instruction.args[0])).type != ValueTypes::Nil;
            }
            if (std::holds_alternative<Value>(instruction.args[0])) {
                toContinue = std::get<Value>(instruction.args[0]).type != ValueTypes::Nil;
            }
            if (toContinue) {
                bool first = true;
                Value returnValue;
                for (auto& arg : instruction.args) {
                    if (first) {
                        first = false;
                    } else {
                        if (std::holds_alternative<Instruction>(arg)) {
                            returnValue = interpretInstruction(std::get<Instruction>(arg));
                        }
                    }
                }
                return returnValue;
            }
            return Value();
        }
        if (instruction.instruction == "while") {
            if (instruction.args.size() < 2) {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }

            while (true) {
                Value conditionResult;
                if (std::holds_alternative<Instruction>(instruction.args[0])) {
                    Instruction condCopy = std::get<Instruction>(instruction.args[0]);
                    conditionResult = interpretInstruction(condCopy);
                } else if (std::holds_alternative<Value>(instruction.args[0])) {
                    conditionResult = std::get<Value>(instruction.args[0]);
                }

                if (conditionResult.type == ValueTypes::Nil) {
                    break;
                }

                for (size_t i = 1; i < instruction.args.size(); i++) {
                    if (std::holds_alternative<Instruction>(instruction.args[i])) {
                        Instruction bodyCopy = std::get<Instruction>(instruction.args[i]);
                        if (bodyCopy.instruction == "break") {
                            return Value();
                        }
                        interpretInstruction(bodyCopy);
                    }
                }
            }
            return Value();
        }
        // Preprocess instructions inside instructions
        for (auto &arg : instruction.args) {
            if (std::holds_alternative<Instruction>(arg)) {
                arg = interpretInstruction(std::get<Instruction>(arg));
            }
        }
        // Instructions that don't require preprocessing go below this line
        // It is safe to use std::get<Value>(...) on all arguments
        if (instruction.instruction == "+" || instruction.instruction == "add") {
            double result = 0;
            for (const auto& arg : instruction.args) {
                auto value = std::get<Value>(arg);
                switch (value.type) {
                    case ValueTypes::Int: {
                        result += value.getInt().value();
                        break;
                    }
                    case ValueTypes::Double: {
                        result += value.getDouble().value();
                        break;
                    }
                    default: {
                        throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
                    }
                }
            }
            if (result == static_cast<int>(result)) {
                return Value(static_cast<int>(result));
            }
            return Value(result);
        }
        if (instruction.instruction == "-" || instruction.instruction == "subtract") {
            if (instruction.args.empty()) return Value(0);

            auto firstValue = std::get<Value>(instruction.args[0]);
            double result = 0;

            if (firstValue.type == ValueTypes::Int) {
                result = firstValue.getInt().value();
            } else if (firstValue.type == ValueTypes::Double) {
                result = firstValue.getDouble().value();
            } else {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }

            for (size_t i = 1; i < instruction.args.size(); i++) {
                auto value = std::get<Value>(instruction.args[i]);
                if (value.type == ValueTypes::Int) {
                    result -= value.getInt().value();
                } else if (value.type == ValueTypes::Double) {
                    result -= value.getDouble().value();
                } else {
                    throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
                }
            }

            if (result == static_cast<int>(result)) {
                return Value(static_cast<int>(result));
            }
            return Value(result);
        }

        if (instruction.instruction == "*" || instruction.instruction == "multiply") {
            if (instruction.args.empty()) return Value(1);

            auto firstValue = std::get<Value>(instruction.args[0]);
            double result = 0;

            if (firstValue.type == ValueTypes::Int) {
                result = firstValue.getInt().value();
            } else if (firstValue.type == ValueTypes::Double) {
                result = firstValue.getDouble().value();
            } else {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }

            for (size_t i = 1; i < instruction.args.size(); i++) {
                auto value = std::get<Value>(instruction.args[i]);
                if (value.type == ValueTypes::Int) {
                    result *= value.getInt().value();
                } else if (value.type == ValueTypes::Double) {
                    result *= value.getDouble().value();
                } else {
                    throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
                }
            }

            if (result == static_cast<int>(result)) {
                return Value(static_cast<int>(result));
            }
            return Value(result);
        }

        if (instruction.instruction == "/" || instruction.instruction == "divide") {
            if (instruction.args.empty()) return Value(1);

            auto firstValue = std::get<Value>(instruction.args[0]);
            double result = 0;

            if (firstValue.type == ValueTypes::Int) {
                result = firstValue.getInt().value();
            } else if (firstValue.type == ValueTypes::Double) {
                result = firstValue.getDouble().value();
            } else {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }

            for (size_t i = 1; i < instruction.args.size(); i++) {
                auto value = std::get<Value>(instruction.args[i]);
                if (value.type == ValueTypes::Int) {
                    if (value.getInt().value() == 0) {
                        throw InterpretingError(InterpreterErrorType::MathError);
                    }
                    result /= value.getInt().value();
                } else if (value.type == ValueTypes::Double) {
                    if (value.getDouble().value() == 0) {
                        throw InterpretingError(InterpreterErrorType::MathError);
                    }
                    result /= value.getDouble().value();
                } else {
                    throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
                }
            }

            if (result == static_cast<int>(result)) {
                return Value(static_cast<int>(result));
            }
            return Value(result);
        }
        if (instruction.instruction == "==" || instruction.instruction == "equal") {
            bool first = true;
            Value firstVal;
            for (const auto& arg : instruction.args) {
                auto value = std::get<Value>(arg);
                if (first) {
                    first = false;
                    firstVal = value;
                } else {
                    if (value != firstVal) {
                        return Value();
                    }
                }
            }
            return Value(1);
        }
        if (instruction.instruction == "!=" || instruction.instruction == "inequal") {
            bool first = true;
            Value firstVal;
            for (const auto& arg : instruction.args) {
                auto value = std::get<Value>(arg);
                if (first) {
                    first = false;
                    firstVal = value;
                } else {
                    if (value == firstVal) {
                        return Value();
                    }
                }
            }
            return Value(1);
        }
        if (instruction.instruction == "input") {
            std::string input;
            linenoise::Readline("", input);
            return Value(input);
        }
        if (instruction.instruction == "let") {
            if (instruction.args.size() < 2) {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }
            auto idval = std::get<Value>(instruction.args[0]);
            std::string id;
            if (idval.type == ValueTypes::Identifier) {
                id = idval.getString().value();
            } else {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }
            environment[id] = std::get<Value>(instruction.args[1]);
            return {environment[id]};
        }
        if (instruction.instruction == "set") {
            if (instruction.args.size() < 2) {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }
            auto idval = std::get<Value>(instruction.args[0]);
            std::string id;
            if (idval.type == ValueTypes::Identifier) {
                id = idval.getString().value();
            } else {
                throw InterpretingError(InterpreterErrorType::IncorrectTokenType);
            }
            if (!environment.contains(id)) {
                throw InterpretingError(InterpreterErrorType::UnknownEnvironment);
            }
            environment[id] = std::get<Value>(instruction.args[1]);
            return {environment[id]};
        }
        if (instruction.instruction == "print") {
            for (const auto& arg : instruction.args) {
                auto value = std::get<Value>(arg);
                value.print();
                std::cout << " ";
            }
            std::cout << "\n";
            return Value();
        }
        if (instruction.instruction == "log") {
            for (const auto& arg : instruction.args) {
                std::cout << "\033[2;3;93m";
                auto value = std::get<Value>(arg);
                value.print();
                std::cout << " ";
            }
            std::cout << "\033[0m\n";
            return Value();
        }
        if (instruction.instruction == "exit") {
            if (!instruction.args.empty()) {
                auto value = std::get<Value>(instruction.args[0]);
                if (value.type == ValueTypes::Int) {
                    exit(value.getInt().value());
                }
            }
            exit(0);
        }
        throw InterpretingError(InterpreterErrorType::UnknownInstruction);
    }
    explicit Interpreter(std::vector<Instruction> in) : instructions(std::move(in)) {
        for (Instruction &instruction : instructions) {
            interpretInstruction(instruction);
        }
    }
    Interpreter() = default;
};

int main(int argc, char** argv) {
    bool isInteractive = true;
    std::string program;
    if (argc > 1) {
        isInteractive = false;
        std::ifstream ifs(argv[1]);
        std::stringstream buffer;
        if (ifs.is_open()) {
            buffer << ifs.rdbuf();
        }
        program = buffer.str();
    }
    linenoise::SetMultiLine(true);
    linenoise::SetHistoryMaxLen(50);
    Parser parser;
    Interpreter interpreter;
    while (true) {
        if (isInteractive) {
            if (linenoise::Readline("pipple> ", program)) {
                return 0;
            }
        }
        try {
            parser = Parser(program);
        } catch (const ParsingError& e) {
            std::cerr << "Parse error: " << e.what() << std::endl;

            // Show code context
            const std::string& source = e.getSourceCode();
            if (!source.empty()) {
                int pos = e.getPosition();

                // Calculate character position in source from token position
                int charPos = 0;
                int tokenCount = 0;
                bool inString = false;

                for (size_t i = 0; i < source.length() && tokenCount < pos; i++) {
                    char c = source[i];
                    if (c == '"') inString = !inString;
                    if (!inString && (c == '(' || c == ')' || c == ' ' || c == '\n')) {
                        if (i > 0 && source[i-1] != ' ' && source[i-1] != '\n' && source[i-1] != '(' && source[i-1] != ')') {
                            tokenCount++;
                        }
                        if (c == '(' || c == ')') tokenCount++;
                    }
                    charPos = static_cast<int>(i);
                }

                // Show context (30 chars before and after)
                int start = std::max(0, charPos - 30);
                int end = std::min(static_cast<int>(source.length()), charPos + 30);

                std::cerr << "\nCode context:\n";
                if (start > 0) std::cerr << "...";
                std::cerr << source.substr(start, end - start);
                if (end < static_cast<int>(source.length())) std::cerr << "...";
                std::cerr << "\n";

                // Show pointer to error position
                int pointerPos = (start > 0 ? 3 : 0) + (charPos - start);
                std::cerr << std::string(pointerPos, ' ') << "^\n";
            }

            if (!isInteractive) return 1;
            continue;
        } catch (const std::exception& e) {
            std::cerr << "Unexpected error: " << e.what() << std::endl;
            if (!isInteractive) return 1;
        }
        try {
            for (auto instruction : parser.instructions) {
                interpreter.interpretInstruction(instruction);
            }

        } catch (const InterpretingError& e) {
            std::cerr << e.what() << std::endl;
            if (!isInteractive) return 1;
        }
        if (!isInteractive) {
            break;
        }
    }
    return 0;
}