#include "parser.h"
#include "utils.h"
#include <iostream>
#include <sstream>
#include <vector>

std::vector<std::string> parseArgs(const std::string& line) {
    std::vector<std::string> args;
    size_t open = line.find('(');
    size_t close = line.find(')');
    if (open == std::string::npos || close == std::string::npos) return args;

    std::string inside = line.substr(open + 1, close - open - 1);
    if (inside.empty()) return args;

    std::stringstream ss(inside);
    std::string segment;
    while (std::getline(ss, segment, ',')) {
        segment = trim(segment);
        // segment to np. "int a". Szukamy ostatniej spacji, by wziąć nazwę "a"
        size_t space = segment.find_last_of(" \t");
        if (space != std::string::npos) {
            args.push_back(trim(segment.substr(space + 1)));
        }
    }
    return args;
}

// Funkcja wyciągająca "tekst" i rejestrująca go w state
// Rejestruje tekst i zwraca jego etykietę (np. str_5)
std::string registerStringLiteral(CompilerState& state, std::string content) {
    // Używamy stringCounter z CompilerState
    std::string label = "str_" + std::to_string(state.stringCounter++);

    // Dodajemy do WEKTORA (push_back działa tylko na wektorze/liście)
    state.stringLiterals.push_back({ label, content });

    return label;
}



void processSource(const std::string& src, CompilerState& state) {
    std::istringstream iss(src);
    std::string line;

    while (std::getline(iss, line)) {
        line = trim(line);
        if (line.empty() || line.substr(0, 2) == "//" || line[0] == '#') continue;

        // --- 1. DEFINICJA FUNKCJI ---
        // Warunki: zaczyna się od typu, ma '(', ma '{' i NIE ma '=' (żeby nie mylić ze zmienną)
        bool startsWithType = (line.rfind("int ", 0) == 0 || line.rfind("void ", 0) == 0 || line.rfind("bool ", 0) == 0);
        if (startsWithType && line.find("(") != std::string::npos && line.find("{") != std::string::npos && line.find("=") == std::string::npos) {

            size_t openParen = line.find('(');
            std::string typeRaw = line.substr(0, line.find(' '));
            std::string nameRaw = line.substr(typeRaw.length(), openParen - typeRaw.length());
            std::string funcName = trim(nameRaw);

            Function newFunc;
            newFunc.name = funcName;
            newFunc.returnType = typeRaw;
            newFunc.args = parseArgs(line);

            state.functions[funcName] = newFunc;
            state.currentFunction = &state.functions[funcName];

            std::cout << "[PARSER] New Function: " << funcName << "\n";
            continue;
        }
        // --- 2. ZAMYKANIE BLOKU '}' ---
                // --- 2. ZAMYKANIE BLOKU '}' ---
        if (line == "}") {
            if (!state.blockStack.empty()) {
                std::string blockInfo = state.blockStack.top();
                state.blockStack.pop();

                // Sprawdzamy czy to WHILE (czy zaczyna się od "WHILE|")
                // Bezpieczniejsza metoda:
                bool isWhile = (blockInfo.length() > 6 && blockInfo.substr(0, 6) == "WHILE|");

                if (isWhile) {
                    // To jest pętla!
                    size_t firstPipe = blockInfo.find('|');
                    size_t secondPipe = blockInfo.rfind('|');

                    std::string labelStart = blockInfo.substr(firstPipe + 1, secondPipe - firstPipe - 1);
                    std::string labelEnd = blockInfo.substr(secondPipe + 1);

                    if (state.currentFunction) {
                        state.currentFunction->instructions.push_back({ OpType::JMP, labelStart, "", "" });
                        state.currentFunction->instructions.push_back({ OpType::LABEL, labelEnd, "", "" });
                    }
                    std::cout << " [PARSER] } End WHILE loop\n";
                }
                else {
                    // To zwykły IF
                    if (state.currentFunction) {
                        state.currentFunction->instructions.push_back({ OpType::LABEL, blockInfo, "", "" });
                    }
                    std::cout << " [PARSER] } End IF block -> " << blockInfo << "\n";
                }
            }
            else {
                // Koniec funkcji
                state.currentFunction = nullptr;
                std::cout << " [PARSER] } End Function\n";
            }
            continue;
        }
        // --- JESTEŚMY W ŚRODKU FUNKCJI ---
        if (state.currentFunction) {
            Function& f = *state.currentFunction;

            // A. RETURN
            if (line.substr(0, 6) == "return") {
                std::string val = trim(line.substr(6));
                if (!val.empty() && val.back() == ';') val.pop_back();
                f.instructions.push_back({ OpType::RETURN, val, "", "" });
                std::cout << " [PARSER] Return: " << val << "\n";
            }
            // --- 4. ZMIENNE TYPU STRING ---
// string s = "hello";
            else if (line.substr(0, 6) == "string") {
                size_t eqPos = line.find("=");
                if (eqPos != std::string::npos) {
                    std::string name = trim(line.substr(7, eqPos - 7));

                    size_t quoteStart = line.find("\"", eqPos);
                    size_t quoteEnd = line.rfind("\"");

                    if (quoteStart != std::string::npos && quoteEnd > quoteStart) {
                        std::string content = line.substr(quoteStart + 1, quoteEnd - quoteStart - 1);

                        // Rejestracja w wektorze
                        std::string label = registerStringLiteral(state, content);

                        // Rejestracja typu w mapie (mapa obsługuje [])
                        state.varTypes[name] = "string";

                        // Instrukcja
                        f.instructions.push_back({ OpType::ASSIGN, name, label, "" });
                    }
                }
            }

            // --- DRUKOWANIE (PRINT) ---
            else if (line.substr(0, 5) == "print") {
                size_t open = line.find("(");
                size_t close = line.rfind(")");
                if (open != std::string::npos && close > open) {
                    std::string content = trim(line.substr(open + 1, close - open - 1));

                    // 1. Literał: print("tekst")
                    if (content.front() == '"' && content.back() == '"') {
                        std::string text = content.substr(1, content.length() - 2);
                        std::string label = registerStringLiteral(state, text);
                        f.instructions.push_back({ OpType::PRINT_STRING, label, "", "" });
                    }
                    // 2. Zmienna: print(x) - sprawdzamy typ
                    // Używamy .count() na mapie varTypes (poprawne)
                    else if (state.varTypes.count(content) && state.varTypes[content] == "string") {
                        f.instructions.push_back({ OpType::PRINT_STRING, content, "", "" });
                    }
                    // 3. Liczba
                    else {
                        f.instructions.push_back({ OpType::PRINT, content, "", "" });
                    }
                }
            }


            // C. IF STATEMENT
                        // --- IF (ZAAWANSOWANY) ---
            else if (line.substr(0, 2) == "if") {
                size_t openParen = line.find("(");
                size_t closeParen = line.rfind(")"); // rfind! Żeby łapać ostatni nawias

                if (openParen != std::string::npos && closeParen > openParen) {
                    std::string conditionRaw = trim(line.substr(openParen + 1, closeParen - openParen - 1));

                    // Zmienna, która będzie trzymać ostateczny wynik warunku
                    std::string finalConditionVar = conditionRaw;

                    // Sprawdzamy czy są operatory logiczne && lub ||
                    // (Na razie obsłużymy jeden poziom: A && B)
                    size_t andPos = conditionRaw.find("&&");
                    size_t orPos = conditionRaw.find("||");

                    if (andPos != std::string::npos) {
                        // Mamy AND: "partA && partB"
                        std::string partA = trim(conditionRaw.substr(0, andPos));
                        std::string partB = trim(conditionRaw.substr(andPos + 2));

                        // Generujemy nazwy zmiennych pomocniczych
                        std::string tempA = "_tmp_and_a_" + std::to_string(state.labelCounter);
                        std::string tempB = "_tmp_and_b_" + std::to_string(state.labelCounter);
                        std::string tempRes = "_tmp_and_res_" + std::to_string(state.labelCounter);

                        // Część A
                        if (partA.find("==") != std::string::npos) {
                            size_t eq = partA.find("==");
                            std::string l = trim(partA.substr(0, eq));
                            std::string r = trim(partA.substr(eq + 2));
                            f.instructions.push_back({ OpType::EQ, tempA, l, r });
                        }
                        else {
                            // Jeśli to po prostu zmienna "a"
                            f.instructions.push_back({ OpType::ASSIGN, tempA, partA, "" });
                        }

                        // Część B
                        if (partB.find("==") != std::string::npos) {
                            size_t eq = partB.find("==");
                            std::string l = trim(partB.substr(0, eq));
                            std::string r = trim(partB.substr(eq + 2));
                            f.instructions.push_back({ OpType::EQ, tempB, l, r });
                        }
                        else {
                            f.instructions.push_back({ OpType::ASSIGN, tempB, partB, "" });
                        }

                        // Wykonujemy AND
                        f.instructions.push_back({ OpType::LOGIC_AND, tempRes, tempA, tempB });
                        finalConditionVar = tempRes;
                    }
                    else if (orPos != std::string::npos) {
                        // To samo dla OR
                        std::string partA = trim(conditionRaw.substr(0, orPos));
                        std::string partB = trim(conditionRaw.substr(orPos + 2));

                        std::string tempA = "_tmp_or_a_" + std::to_string(state.labelCounter);
                        std::string tempB = "_tmp_or_b_" + std::to_string(state.labelCounter);
                        std::string tempRes = "_tmp_or_res_" + std::to_string(state.labelCounter);

                        // A
                        if (partA.find("==") != std::string::npos) {
                            size_t eq = partA.find("==");
                            f.instructions.push_back({ OpType::EQ, tempA, trim(partA.substr(0, eq)), trim(partA.substr(eq + 2)) });
                        }
                        else f.instructions.push_back({ OpType::ASSIGN, tempA, partA, "" });

                        // B
                        if (partB.find("==") != std::string::npos) {
                            size_t eq = partB.find("==");
                            f.instructions.push_back({ OpType::EQ, tempB, trim(partB.substr(0, eq)), trim(partB.substr(eq + 2)) });
                        }
                        else f.instructions.push_back({ OpType::ASSIGN, tempB, partB, "" });

                        f.instructions.push_back({ OpType::LOGIC_OR, tempRes, tempA, tempB });
                        finalConditionVar = tempRes;
                    }
                    else if (conditionRaw.find("==") != std::string::npos) {
                        size_t eq = conditionRaw.find("==");
                        std::string l = trim(conditionRaw.substr(0, eq));
                        std::string r = trim(conditionRaw.substr(eq + 2));
                        std::string tempRes = "_tmp_eq_" + std::to_string(state.labelCounter);

                        f.instructions.push_back({ OpType::EQ, tempRes, l, r });
                        finalConditionVar = tempRes;
                    }

                    // --- GENEROWANIE SKOKU ---
                    std::string labelName = "L_" + std::to_string(state.labelCounter++);

                    // Teraz JMP_FALSE dostaje zawsze już obliczoną zmienną (finalConditionVar)
                    f.instructions.push_back({ OpType::JMP_FALSE, labelName, finalConditionVar, "" });
                    state.blockStack.push(labelName);

                    std::cout << " [PARSER] IF (" << finalConditionVar << ") -> Jump to " << labelName << "\n";
                }
            }

            // --- PĘTLA WHILE ---
            else if (line.substr(0, 5) == "while") {
                size_t openParen = line.find("(");
                size_t closeParen = line.find(")");
                if (openParen != std::string::npos && closeParen > openParen) {
                    std::string condition = trim(line.substr(openParen + 1, closeParen - openParen - 1));

                    // 1. Generujemy etykiety
                    std::string labelStart = "L_" + std::to_string(state.labelCounter++);
                    std::string labelEnd = "L_" + std::to_string(state.labelCounter++);

                    // 2. Wstawiamy etykietę START (tu będziemy wracać)
                    f.instructions.push_back({ OpType::LABEL, labelStart, "", "" });

                    // 3. Sprawdzamy warunek -> jak fałsz, skaczemy do END
                    f.instructions.push_back({ OpType::JMP_FALSE, labelEnd, condition, "" });

                    // 4. Wrzucamy info na stos, żeby '}' wiedziało co robić
                    // Format specjalny: "WHILE|Start|End"
                    state.blockStack.push("WHILE|" + labelStart + "|" + labelEnd);

                    std::cout << " [PARSER] WHILE (" << condition << ") -> Loop between " << labelStart << " and " << labelEnd << "\n";
                }
            }
            // D. PRZYPISANIE ZMIENNEJ (LUB DEKLARACJA)
            // np. "int a = 5;" LUB "a = b + c;"
            else if (line.find("=") != std::string::npos) {
                size_t eqPos = line.find('=');
                std::string leftSide = trim(line.substr(0, eqPos));
                std::string rightSide = trim(line.substr(eqPos + 1));

                bool isStringDecl = false; // Flaga, czy to string
                if (!rightSide.empty() && rightSide.back() == ';') rightSide.pop_back();

                // Obsługa nazwy zmiennej (usuwanie "int ", "bool ")
                std::string varName = leftSide;
                if (leftSide.rfind("int ", 0) == 0) varName = trim(leftSide.substr(4));
                else if (leftSide.rfind("bool ", 0) == 0) varName = trim(leftSide.substr(5));
                else if (leftSide.rfind("string ", 0) == 0) {
                    varName = trim(leftSide.substr(7));
                    isStringDecl = true;
                }


                // 1. Czy to wywołanie funkcji? int x = func();
                if (rightSide.find("(") != std::string::npos && rightSide.find(")") != std::string::npos) {
                    size_t open = rightSide.find('(');
                    std::string funcName = trim(rightSide.substr(0, open));
                    std::string argsContent = rightSide.substr(open + 1, rightSide.find(')') - open - 1);

                    // CALL func
                    f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
                    // ASSIGN result (RAX) to variable
                    f.instructions.push_back({ OpType::ASSIGN, varName, "RAX", "" });
                    std::cout << " [PARSER] Call & Assign: " << varName << " = " << funcName << "()\n";
                }
                // 2. Czy to dodawanie? a + b
                else if (rightSide.find("+") != std::string::npos) {
                    size_t opPos = rightSide.find("+");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 1));
                    f.instructions.push_back({ OpType::ADD, varName, a, b });
                }
                // 3. NOWOŚĆ: Czy to odejmowanie? a - b
                else if (rightSide.find("-") != std::string::npos) {
                    size_t opPos = rightSide.find("-");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 1));
                    f.instructions.push_back({ OpType::SUB, varName, a, b }); // <--- Używamy SUB
                }
                // 4. NOWOŚĆ: Czy to mnożenie? a * b
                else if (rightSide.find("*") != std::string::npos) {
                    size_t opPos = rightSide.find("*");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 1));
                    f.instructions.push_back({ OpType::MUL, varName, a, b }); // <--- Używamy MUL
                }
                else if (rightSide.find("/") != std::string::npos) {
                    size_t opPos = rightSide.find("/");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 1));
                    f.instructions.push_back({ OpType::DIV, varName, a, b });
                }
                // MODULO: a % b
                else if (rightSide.find("%") != std::string::npos) {
                    size_t opPos = rightSide.find("%");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 1));
                    f.instructions.push_back({ OpType::MOD, varName, a, b });
                }
                // LOGICZNE AND: a && b
                else if (rightSide.find("&&") != std::string::npos) {
                    size_t opPos = rightSide.find("&&");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 2)); // +2 bo && ma 2 znaki
                    f.instructions.push_back({ OpType::LOGIC_AND, varName, a, b });
                }
                // LOGICZNE OR: a || b
                else if (rightSide.find("||") != std::string::npos) {
                    size_t opPos = rightSide.find("||");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 2));
                    f.instructions.push_back({ OpType::LOGIC_OR, varName, a, b });
                }
                // 3. Czy to porównanie? a == b (Ważne: == może być w IFie, ale tu jesteśmy w linii z '=')
                // UWAGA: To rzadkie w C++ (bool x = a == b), ale obsłużmy proste przypisanie wartości logicznej
                else if (rightSide.find("==") != std::string::npos) {
                    size_t opPos = rightSide.find("==");
                    std::string a = trim(rightSide.substr(0, opPos));
                    std::string b = trim(rightSide.substr(opPos + 2));
                    f.instructions.push_back({ OpType::EQ, varName, a, b });
                }
                // 4. Zwykłe przypisanie: a = 5
                else {
                    f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
                }
            }
            // E. SAMODZIELNE WYWOŁANIE FUNKCJI (bez =)
            // np. func();
            else if (line.find("(") != std::string::npos && line.find(")") != std::string::npos) {
                size_t open = line.find('(');
                std::string funcName = trim(line.substr(0, open));
                std::string argsContent = line.substr(open + 1, line.find(')') - open - 1);

                f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
                std::cout << " [PARSER] Call void: " << funcName << "\n";
            }
        }
    }
}
void calculateExpressions(CompilerState& state) {}