#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <vector>
#include <cstdlib>

std::vector<std::string> splitString(const std::string& input, const std::string& delimiters) {
    std::vector<std::string> tokens;
    std::istringstream tokenStream(input);
    std::string token;

    while (std::getline(tokenStream, token, delimiters[0])) {
        for (size_t i = 1; i < delimiters.size(); ++i) {
            // For each additional delimiter, split the token and add it to the list.
            std::istringstream subTokenStream(token);
            std::string subToken;
            while (std::getline(subTokenStream, subToken, delimiters[i])) {
                tokens.push_back(subToken);
            }
            token = tokens.empty() ? "" : tokens.back();
            tokens.pop_back();
        }
        tokens.push_back(token);
    }

    return tokens;
}

static std::vector<unsigned char> Memory;
static std::vector<unsigned char> x;
static std::vector<unsigned char> y;
static std::vector<unsigned char> z = {{0}};

class virtual_machine {
    public:
        int virtual_cores;

    static struct instructionFunctions {
        public:
            int operator[](int index) const {
                // Access the element at the specified index
                return data[index];
            }

        private:
            std::vector<int> data = {1, 2, 3, 4, 5};
        };

        int clr() {
            Memory = {};
            return 0;
        }
        int add(int a1, int a2) {
            return a1+a2;
        }
        int sub(int a1, int a2) {
            return a1-a2;
        }
        int mul(int a1, int a2) {
            return a1*a2;
        }
        int f(int a1, int a2) {
            return mul(a1,a2);
        }
        int div(int a1, int a2) {
            return a1/a2;
        }
        int mod(int a1, int a2) {
            return a1%a2;
        }
        static int ldx(int i) {
            if (i >= 0 && i < 16) {
                x[i] = y[i];
            } else {
                std::cout << "Invalid x index: " << i << std::endl;
            }
            return 0;
        }

        static int ldy(int i) {
            if (i >= 0 && i < 16) {
            y[i] = Memory[y[i]];
            } else {
                std::cout << "Invalid y index: " << i << std::endl;
            }
            return 0;
        }

        static int ldz(int i) {
            if (i >= 0 && i < 16) {
                z[i] = Memory[z[i]];
            } else {
                std::cout << "Invalid z index: " << i << std::endl;
            }
            return 0;
        }

        static int ldzi(int i) {
            if (i >= 0 && i < 16) {
                ldz(i);
            } else {
                std::cout << "Invalid z index: " << i << std::endl;
            }
            return 0;
        }

        static int stx(int i) {
            if (i >= 0 && i < 16) {
                y[i] = x[i];
            } else {
                std::cout << "Invalid x index: " << i << std::endl;
            }
            return 0;
        }

        static int sty(int i) {
            if (i >= 0 && i < 16) {
                if (y[i] >= 0 && y[i] < Memory.size()) {
                    Memory[y[i]] = y[i];
                } else {
                    std::cout << "Invalid memory index in y: " << y[i] << std::endl;
                }
            } else {
                std::cout << "Invalid y index: " << i << std::endl;
            }
            return 0;
        }

        static int stz(int i) {
            if (i >= 0 && i < 16) {
                if (z[i] >= 0 && z[i] < Memory.size()) {
                    Memory[z[i]] = z[i];
                } else {
                    std::cout << "Invalid memory index in z: " << z[i] << std::endl;
                }
                } else {
                    std::cout << "Invalid z index: " << i << std::endl;
                }
                return 0;
        }

        static int stzi(int i) {
            if (i >= 0 && i < 16) {
                stz(i);
            } else {
                std::cout << "Invalid z index: " << i << std::endl;
            }
            return 0;
        }

        int fma(int j, int i) {
            z[Memory[i]] += x[i] * y[j];
            return 0;
        }
        int fma64(int j, int i) {
            fma(j,i);
            return 0;
        }
        int fma32(int j, int i) {
            fma(j,i);
            return 0;
        }
        int fma16(int j, int i) {
            fma(j,i);
            return 0;
        }
        int fms(int j, int i) {
            z[Memory[i]] += x[i] * y[j];
            return 0;
        }
        int fms64(int j, int i) {
            fms(j,i);
            return 0;
        }
        int fms32(int j, int i) {
            fms(j,i);
            return 0;
        }
        int fms16(int j, int i) {
            fms(j,i);
            return 0;
        }
        int matfp(int j,int i, int addOrSubtract) {
            if (addOrSubtract == 1) {
                z[Memory[i]] += x[i] * y[j];
            } else {
                z[Memory[i]] -= x[i] * y[j];
            }
            return 0;
        }
        int mac16(int j, int i) {
            matfp(j,i,1);
            return 0;
        }
        int matint(int j,int i,int addOrSubtract,int fourtySeven) {
            if (47 == 4) {
                return 0;
            } else {
                if (addOrSubtract == 1) {
                    z[Memory[i]] += x[i] * y[j];
                } else {
                    z[Memory[i]] -= x[i] * y[j];
                }
                return 0;
            }
            return 1;
        }
        int vecfp(int i,int addOrSubtract) {
            if (addOrSubtract == 1) {
                z[i] += x[i] * y[i];
            } else {
                z[i] -= x[i] * y[i];
            }
            return 0;
        }
        int vecint(int i,int fourtySeven,int addOrSubtract) {
            if (fourtySeven == 4) {
                z[i] *- i;
            } else {
                if (addOrSubtract == 1) {
                    z[i] += x[i] * y[i];
                } else {
                    z[i] -= x[i] * y[i];
                }
            }
            return 0;
        }
        int extrx(int i) {
            x[i] = y[i];
            return 0;
        }
        int extry(int i) {
            y[i] = x[i];
            return 0;
        }
        int extrh(int i, int twentySix) {
            if (twentySix == 0) {
                x[i] = z[i];
            } else {
                x[i] = i * z[i];
            }
            return 0;
        }
        int andInstuction(int j, int i) {
            z[i] &= j;
        }
        int orr(int j, int i) {
            z[i] |= j;
        }
        int eor(int j, int i) {
            z[i] ^= j;
        }
        //function that loads a value from memory into a register (lor)
        int lor(int j, int i) {
            y[i] = j;
        }
        int str(int i) {
            //store a value from a register into memory
            y[i] = z[i];
            return 0;
        }
        //unconditional branch to specified address function (B)
        int b(int i) {
            return y[i];
        }
        //branch if the zero flag is set (BEQ)
        int beq(int i) {
            if (z[i] == 0) {
                return y[i];
            }
        }
        //branch if the zero flag is not set (BNE)
        int bne(int i) {
            if (z[i] != 0) {
                return y[i];
            }
        }
        //branch if the carry flag is set (BCS)
        int bcs(int i) {
            if (z[i] == 1) {
                return y[i];
            }
        }
        //branch if the carry flag is not set (BCC)
        int bcc(int i) {
            if (z[i] != 1) {
                return y[i];
            }
        }
        //BL function
        int bl(int i) {
            return y[i];
        }
        //CMP function
        int cmp(int j, int i) {
            if (z[i] == j) {
                return 0;
            }
        }

        int mov(int j, int i) {
            //move a value from one register to another
            z[i] = j;
        }
        int udiv(int j, int i) {
            return z[i] / j;
        }
        int sdiv(int j, int i) {
            return z[i] / j;
        }
        void lsl(int i) {
            z[i] = z[i] << 1;
        }
        void lsr(int i) {
            z[i] = z[i] >> 1;
        }
        void asr(int i) {
            z[i] = z[i] >> 1;
        }
        void ror(int i) {
            z[i] = z[i] >> 1;
        }
        int cbz(int i) {
            if (z[i] == 0) {
                return y[i];
            }
        }
        int cbnz(int i) {
            if (z[i] != 0) {
                return y[i];
            }
        }
        int cbeq(int i) {
            if (z[i] == 0) {
                return y[i];
            }
        }
        int cbne(int i) {
            if (z[i] != 0) {
                return y[i];
            }
        }
        int cble(int i) {
            if (z[i] <= 0) {
                return y[i];
            }
        }
        int cbgt(int i) {
            if (z[i] > 0) {
                return y[i];
            }
        }
        int ldm(int i) {
            return y[i];
        }
        int stm(int i) {
            return y[i];
        }
        float fadd(int j, int i) {
         return i+j;   
        }
        float fsub(int j, int i) {
            return i-j;
        }
        float fmul(int j, int i) {
            return i*j;
        }
        float fdiv(int j, int i) {
            return i/j;
        }
        float fmod(int j, int i) {
            return i%j;
        }
        int fcmp(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //ccmn instruction
        int ccmn(int j, int i) {
            if (i != j) {
                return 0;
            } else {
                return 1;
            }
        }
        //ccmp instruction
        int ccmp(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //csel instruction
        int csel(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //csinc instruction
        int csinc(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //csinv instruction
        int csinv(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //cneg instruction
        int cneg(int j, int i) {
            if (i == j) {
                return 0;
            } else {
                return 1;
            }
        }
        //sys instruction
        int sys(int i) {
            return 0;
        }
        //halt instructin
        int halt() {
            std::exit(1);
        }
        //HINT instruction
        int hint() {
            return 0;
        }
        //MSR instruction
        int msr() {
            return 0;
        }
        //MRS instruction
        int mrs() {
            return 0;
        }
        //BRK instruction
        int brk() {
            std::exit(0);
        }
        void umod(int j, int i) {
            z[i] %= j;
        }
        template <typename T>
        T ldr(const std::vector<unsigned char>& memory, uintptr_t address) {
            T value;
            std::memcpy(&value, memory.data() + address, sizeof(T));
            return value;
        }
        template <typename T>
        void str(std::vector<unsigned char>& memory, uintptr_t address, T value) {
            std::memcpy(memory.data() + address, &value, sizeof(T));
        }
    } instructionFunctions;
    static bool isTokenInArray(const std::vector<std::string>& array, const std::string& token) {
        return std::find(array.begin(), array.end(), token) != array.end();
    }
    static void executeInstruction(const std::string& instruction, const std::vector<std::string>& operands) {
        if (instruction == "add") {
            if (operands.size() == 2) {
                instructionFunctions.add(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if ( instruction == "sub") {
            if (operands.size() == 2) {
                instructionFunctions.sub(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "mul") {
            if (operands.size() == 2) {
                instructionFunctions.mul(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "div") {
            if (operands.size() == 2) {
                instructionFunctions.div(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "mod") {
            if (operands.size() == 2) {
                instructionFunctions.mod(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "cmp") {
            if (operands.size() == 2) {
                instructionFunctions.cmp(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "ccmn") {
            if (operands.size() == 2) {
                instructionFunctions.ccmn(std::stoi(operands[0]), std::stoi(operands[1]));
            }   
        } else if (instruction == "ccmp") {
            if (operands.size() == 2) {
                instructionFunctions.ccmp(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "csel") {
            if (operands.size() == 2) {
                instructionFunctions.csel(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "csinc") {
            if (operands.size() == 2) {
                instructionFunctions.csinc(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "csinv") {
            if (operands.size() == 2) {
                instructionFunctions.csinv(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "cneg") {
            if (operands.size() == 2) {
                instructionFunctions.cneg(std::stoi(operands[0]), std::stoi(operands[1]));
            }
        } else if (instruction == "sys") {
            instructionFunctions.sys(std::stoi(operands[0]));
        } else if (instruction == "halt") {
            instructionFunctions.halt();
        } else if (instruction == "hint") {
            instructionFunctions.hint();
        } else if (instruction == "msr") {
            instructionFunctions.msr();
        } else if (instruction == "mrs") {
            instructionFunctions.mrs();
        } else if (instruction == "brk") {
            instructionFunctions.brk();
        } else if (instruction == "lsl") {
            instructionFunctions.lsl(std::stoi(operands[0]));
        } else if (instruction == "lsr") {
            instructionFunctions.lsr(std::stoi(operands[0]));
        } else if (instruction == "asr") {
            instructionFunctions.asr(std::stoi(operands[0]));
        } else if (instruction == "ror") {
            instructionFunctions.ror(std::stoi(operands[0]));
        } else if (instruction == "cbz") {
            instructionFunctions.cbz(std::stoi(operands[0]));
        } else if (instruction == "cbnz") {
            instructionFunctions.cbnz(std::stoi(operands[0]));
        } else if (instruction == "cbeq") {
            instructionFunctions.cbeq(std::stoi(operands[0]));
        } else if (instruction == "cbne") {
            instructionFunctions.cbne(std::stoi(operands[0]));
        } else if (instruction == "cble") {
            instructionFunctions.cble(std::stoi(operands[0]));
        } else if (instruction == "cbgt") {
            instructionFunctions.cbgt(std::stoi(operands[0]));
        } else if (instruction == "ldr") {
            std::string intValue = operands[0];
            uintptr_t uintptrValue = std::stoull(intValue);
            instructionFunctions.ldr<int>(Memory, uintptrValue);
        } else if (instruction == "str") {
            std::string intValue = operands[0];
            uintptr_t uintptrValue = std::stoull(intValue);
            instructionFunctions.str(Memory, uintptrValue, operands[1]); //note: operands[1] is the value to be stored. it should be a string, for compatibility and future use.
        } else if (instruction == "f") {
            instructionFunctions.f(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "mod") {
            instructionFunctions.mod(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "extrh") {
            instructionFunctions.extrh(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "extrx") {
            instructionFunctions.extrx(std::stoi(operands[0]));
        } else if (instruction == "extry") {
            instructionFunctions.extry(std::stoi(operands[0]));
        } else if (instruction == "b") {
            instructionFunctions.b(std::stoi(operands[0]));
        } else if (instruction == "beq") {
            instructionFunctions.beq(std::stoi(operands[0]));
        } else if (instruction == "bne") {
            instructionFunctions.bne(std::stoi(operands[0]));
        } else if (instruction == "orr") {
            instructionFunctions.orr(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "eor") {
            instructionFunctions.eor(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "bl") {
            instructionFunctions.bl(std::stoi(operands[0]));
        } else if (instruction == "mov") {
            instructionFunctions.mov(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "udiv") {
            instructionFunctions.udiv(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "sdiv") {
            instructionFunctions.sdiv(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "umod") {
            instructionFunctions.umod(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "smod") {
            instructionFunctions.umod(std::stoi(operands[0]), std::stoi(operands[1]));
        } else if (instruction == "and") {
            instructionFunctions.andInstuction(std::stoi(operands[0]), std::stoi(operands[1]));
        } else {
            std::cout << "Invalid instruction"  << std::endl;
            std::exit(1);
        }
        std::cout << "Successfully simulated instruction: " << instruction << std::endl;
    }
    //assembly function
     static void executeASM(std::string inputASM) {
        std::vector<std::string> operands;  // To store operands for each instruction
        //an array of all the names of the instruction functions, to be used later
        std::vector<std::string> instructionFunctionsNames = {"add", "sub", "mul", "div", "mod", "cmp", "ccmn", "ccmp", "csel", "csinc", "csinv", "cneg", "sys", "halt", "hint", "msr", "mrs", "brk", "lsl", "lsr", "asr", "ror", "cbz", "cbnz", "cbeq", "cbne", "cble", "cbgt", "ldr", "str", "f", "mod", "extrh", "extrx", "extry", "b", "beq", "bne", "orr", "eor", "bl", "mov", "udiv", "umod", "and"};
        std::string currentInstruction;     // To keep track of the current instruction
        virtual_machine vm;

        // Define a list of delimiters
        std::string delimiters = " ,;\n";


        std::vector<std::string> tokens = splitString(inputASM, delimiters);
        for (const std::string& token : tokens) {

        // if the instruction is and execute the andInstruction function
        if (token == "and") {
            instructionFunctions.andInstuction(std::stoi(operands[0]), std::stoi(operands[1]));
            return;
        }

        if (isTokenInArray(instructionFunctionsNames, token)) {
            if (!currentInstruction.empty()) {
                // Execute the previous instruction
                executeInstruction(currentInstruction, operands);
            }
            currentInstruction = token;
            operands.clear();
        } else {
            // Collect operands
            operands.push_back(token);
        }
         std::cout << "Simulation instruction added for processing." << std::endl;
    }

    // Execute the last instruction
    if (!currentInstruction.empty()) {
        executeInstruction(currentInstruction, operands);
    }
    std::cout << "Simulation instruction completed." << std::endl;
}
     

int main(){
    // get assembly code from user input
    std::string assembly;
    std::cout << "Enter assembly code: ";
    std::getline(std::cin, assembly);
    executeASM(assembly);
    return 0;
}