#include "code.hpp"


std::ostringstream stream;

namespace interp {
    
    std::vector<TextLine> lines;
    std::unordered_map<std::string, int> label_table;
    std::unordered_map<int, int> label_line_table;
    
    const char *add_mode[] = { "Non mode", "Immediate", "Zero Page", "Zero Page X", "Zero Page Y", "Absoulte", "Absoulte X", "Absoulte Y", "Implied", "Relative", "Indirect Indexed", "Indexed Indirect", "Accumulator", "Indirect", 0 };
    

    using namespace icode;

    iCodeInstruction inst[] = { {opc::ADC, i_adc }, {opc::AND, i_and}, {opc::ASL, i_asl},
        {opc::BCC, i_bcc}, {opc::BCS, i_bcs}, {opc::BEQ, i_beq}, {opc::BIT, i_bit},
        {opc::BMI, i_bmi}, {opc::BNE, i_bne}, {opc::BPL, i_bpl}, {opc::BRK, i_brk},
        {opc::BVC, i_bvc}, {opc::BVS, i_bvs}, {opc::CLC, i_clc}, {opc::CLD, i_cld},
        {opc::CLI, i_cli}, {opc::CLV, i_clv}, {opc::CMP, i_cmp}, {opc::CPX, i_cpx},
        {opc::CPY, i_cpy}, {opc::DEC, i_dec}, {opc::DEX, i_dex}, {opc::DEY, i_dey},
        {opc::END, i_end},
        {opc::EOR, i_eor}, {opc::INC, i_inc}, {opc::INT, i_int}, {opc::INX, i_inx},
        {opc::INY, i_iny}, {opc::JMP, i_jmp}, {opc::JSR, i_jsr}, {opc::LDA, i_lda},
        {opc::LDM, i_ldm}, {opc::LDX, i_ldx}, {opc::LDY, i_ldy}, {opc::LSR, i_lsr},
        {opc::NOP, i_nop}, {opc::ORA, i_ora}, {opc::PHA, i_pha}, {opc::PHP, i_php},
        {opc::PLA, i_pla}, {opc::PLP, i_plp}, {opc::ROL, i_rol}, {opc::ROR, i_ror},
        {opc::RTI, i_rti}, {opc::RTS, i_rts}, {opc::SBC, i_sbc}, {opc::SEC, i_sec},
        {opc::SED, i_sed}, {opc::SEI, i_sei}, {opc::STA, i_sta}, {opc::STX, i_stx},
        {opc::STY, i_sty}, {opc::TAX, i_tax}, {opc::TAY, i_tay}, {opc::TSX, i_tsx},
        {opc::TXA, i_txa}, {opc::TXS, i_txs}, {opc::TYA, i_tya}
    };
    
    at_code m_code[] = {
        // ADC
        { 0x69, IMMEDIATE, opc::ADC }, { 0x65, ZEROPAGE, opc::ADC },{ 0x75, ZEROPAGE_X, opc::ADC }, { 0x6D, ABSOULTE, opc::ADC }, {0x7D, ABSOULTE_X, opc::ADC }, { 0x79, ABSOULTE_Y, opc::ADC},{ 0x61, INDEXED_I, opc::ADC }, { 0x71, INDIRECT_I, opc::ADC },
        // AND
        { 0x29, IMMEDIATE, opc::AND }, {0x25, ZEROPAGE, opc::AND}, {0x35, ZEROPAGE_X, opc::AND}, {0x2D, ABSOULTE, opc::AND},{ 0x3D, ABSOULTE_X, opc::AND }, {0x39, ABSOULTE_Y, opc::AND }, {0x21, INDEXED_I, opc::AND}, {0x31, INDIRECT_I, opc::AND},
        // ASL
        { 0x0A, ACCUMULATOR, opc::ASL }, {0x06, ZEROPAGE, opc::ASL}, {0x16, ZEROPAGE_X, opc::ASL}, {0x0E, ABSOULTE, opc::ASL},{ 0x1E, ABSOULTE_X, opc::ASL },
        // BCC
        { 0x90, RELATIVE, opc::BCC},
        // BCS
        { 0xB0, RELATIVE, opc::BCS},
        // BEQ
        { 0xF0, RELATIVE, opc::BEQ},
        // BIT
        { 0x24, ZEROPAGE, opc::BIT}, {0x2C, ABSOULTE, opc::BIT},
        // BMI
        { 0x30, RELATIVE, opc::BMI},
        // BNE
        { 0xD0, RELATIVE, opc::BNE},
        // BPL
        { 0x10, RELATIVE, opc::BPL},
        // BRK
        { 0x00, IMPLIED, opc::BRK},
        // BVC
        { 0x50, RELATIVE, opc::BVC},
        // BVS
        { 0x70, RELATIVE, opc::BVC},
        // CLC
        { 0x18, IMPLIED, opc::CLC},
        // CLD
        { 0xD8, IMPLIED, opc::CLD},
        // CLI
        { 0x58, IMPLIED, opc::CLI},
        // CLV
        { 0xB8, IMPLIED, opc::CLV},
        // CMP
        { 0xC9, IMMEDIATE, opc::CMP}, {0xC5, ZEROPAGE, opc::CMP}, { 0xD5, ZEROPAGE_X, opc::CMP }, { 0xCD, ABSOULTE, opc::CMP},{ 0xDD, ABSOULTE_X, opc::CMP}, {0xD9, ABSOULTE_Y, opc::CMP}, {0xD9, ABSOULTE_Y, opc::CMP}, { 0xC1, INDEXED_I, opc::CMP},{ 0xD1, INDIRECT_I, opc::CMP},
        // CPX
        { 0xE0, IMMEDIATE, opc::CPX}, {0xE4, ZEROPAGE, opc::CPX}, {0xEC, ABSOULTE, opc::CPX},
        // CPY
        { 0xC0, IMMEDIATE, opc::CPY}, {0xC4, ZEROPAGE, opc::CPY}, {0xCC, ABSOULTE, opc::CPY},
        // DEC
        { 0xC6, ZEROPAGE, opc::DEC}, {0xD6, ZEROPAGE_X, opc::DEC}, {0xCE, ABSOULTE, opc::DEC}, {0xDE, ABSOULTE_X, opc::DEC},
        // DEX
        { 0xCA, IMPLIED, opc::DEX},
        // DEY
        { 0x88, IMPLIED, opc::DEY},
        // END
        { 0x01, IMPLIED, opc::END},
        // EOR
        { 0x49, IMMEDIATE, opc::EOR}, {0x45, ZEROPAGE, opc::EOR}, {0x55, ZEROPAGE_X, opc::EOR}, {0x4D, ABSOULTE, opc::EOR},{ 0x5D, ABSOULTE_X, opc::EOR}, {0x59, ABSOULTE_Y, opc::EOR}, {0x41, INDEXED_I, opc::EOR}, {0x51, INDIRECT_I, opc::EOR},
        // INC
        {0xE6, ZEROPAGE, opc::INC}, {0xF6, ZEROPAGE_X, opc::INC}, {0xEE, ABSOULTE, opc::INC}, {0xFE, ABSOULTE_X, opc::INC},
        // INX
        {0xE8, IMPLIED, opc::INX},
        // INY
        {0xC8, IMPLIED, opc::INY},
        // JMP
        {0x4C, ABSOULTE, opc::JMP}, {0x6C, INDIRECT, opc::JMP},
        // JSR
        {0x20, ABSOULTE, opc::JSR},
        // LDA
        { 0xA9, IMMEDIATE, opc::LDA}, {0xA5, ZEROPAGE, opc::LDA}, {0xB5, ZEROPAGE_X, opc::LDA}, {0xAD, ABSOULTE, opc::LDA},{ 0xBD, ABSOULTE_X, opc::LDA}, {0xB9, ABSOULTE_Y, opc::LDA}, {0xA1, INDEXED_I, opc::LDA}, {0xB1, INDIRECT_I, opc::LDA},
        // LDX
        {0xA2, IMMEDIATE, opc::LDX}, {0xA6, ZEROPAGE, opc::LDX}, {0xB6, ZEROPAGE_Y, opc::LDX}, {0xAE, ABSOULTE, opc::LDX},{0xA1, INDEXED_I, opc::LDX},{0xB1, INDIRECT_I, opc::LDX}, {0xBE, ABSOULTE_Y, opc::LDX},
        // LDY
        {0xA0, IMMEDIATE, opc::LDY}, {0xA4, ZEROPAGE, opc::LDY}, {0xB4, ZEROPAGE_X, opc::LDY}, {0xAC, ABSOULTE, opc::LDY},{0xBC, ABSOULTE_X, opc::LDY},
        // LSR
        {0x4A, ACCUMULATOR, opc::LSR}, {0x46, ZEROPAGE, opc::LSR}, {0x56, ZEROPAGE_X, opc::LSR}, {0x4E, ABSOULTE, opc::LSR},{0x5E, ABSOULTE_X, opc::LSR},
        // NOP
        {0xEA, IMPLIED, opc::NOP},
        // ORA
        {0x09, IMMEDIATE, opc::ORA}, {0x05, ZEROPAGE, opc::ORA}, {0x15, ZEROPAGE_X, opc::ORA}, {0x0D, ABSOULTE, opc::ORA},{0x1D, ABSOULTE_X, opc::ORA}, {0x19, ABSOULTE_Y, opc::ORA}, {0x01, INDEXED_I, opc::ORA}, {0x11, INDIRECT_I, opc::ORA},
        // PHA
        {0x48, IMPLIED, opc::PHA},
        // PHP
        {0x08, IMPLIED, opc::PHP},
        // PLA
        {0x68, IMPLIED, opc::PLA},
        // PLP
        {0x28, IMPLIED, opc::PLP},
        // ROL
        {0x21, ACCUMULATOR, opc::ROL},{0x26, ZEROPAGE, opc::ROL}, {0x36, ZEROPAGE_X, opc::ROL}, {0x2E, ABSOULTE, opc::ROL},{0x3E, ABSOULTE_X, opc::ROL},
        // ROR
        {0x6A, ACCUMULATOR, opc::ROR}, {0x66, ZEROPAGE, opc::ROR}, {0x76, ZEROPAGE_X, opc::ROR}, {0x6E, ABSOULTE, opc::ROR},{0x7E, ABSOULTE_X, opc::ROR},
        // RTI
        {0x40, IMPLIED, opc::RTI},
        // RTS
        {0x60, IMPLIED, opc::RTS},
        // SBC
        { 0xE9, IMMEDIATE, opc::SBC}, {0xE5, ZEROPAGE, opc::SBC}, {0xF5, ZEROPAGE_X, opc::SBC}, {0xED, ABSOULTE, opc::SBC},{ 0xFD, ABSOULTE_X, opc::SBC}, {0xF9, ABSOULTE_Y, opc::SBC}, {0xE1, INDEXED_I, opc::SBC}, {0xF1, INDIRECT_I, opc::SBC},
        // SEC
        {0x38, IMPLIED, opc::SEC},
        // SED
        {0xF8, IMPLIED, opc::SED},
        // SEI
        {0x78, IMPLIED, opc::SEI},
        // STA
        { 0x85, ZEROPAGE, opc::STA}, {0x95, ZEROPAGE_X, opc::STA}, {0x8D, ABSOULTE, opc::STA}, {0x9D, ABSOULTE_X, opc::STA},{ 0x99, ABSOULTE_Y, opc::STA}, {0x81, INDEXED_I, opc::STA}, {0x91, INDIRECT_I, opc::STA},
        // STX
        { 0x86, ZEROPAGE, opc::STX}, {0x96,  ZEROPAGE_Y, opc::STX}, {0x8E, ABSOULTE, opc::STX},
        // STY
        { 0x84, ZEROPAGE, opc::STY}, {0x94, ZEROPAGE_X, opc::STY}, {0x8C, ABSOULTE, opc::STY},
        // TAX
        { 0xAA, IMPLIED, opc::TAX},
        // TAY
        { 0xA8, IMPLIED, opc::TAY},
        // TSX
        { 0xBA, IMPLIED, opc::TSX},
        // TXA
        { 0x8A, IMPLIED, opc::TXA},
        // TXS
        { 0x9A, IMPLIED, opc::TXS},
        // TYA
        { 0x98, IMPLIED, opc::TYA},
        { 0x0, 0x0, opc::NOTINC }
    };
    
    void testcodes() {
        for(unsigned int i = 0; icode::op_array[i] != 0; ++i) {
            icode::opc c = static_cast<icode::opc>(i);
            if(inst[i].opcode == c) {
                stream << icode::op_array[i] << " correct.\r\n";
            } else {
                stream << icode::op_array[i] << " incorrect.\r\n";
            }
        }
    }
    
    Code::Code() {
        reset_memory();
    }
    
    void Code::start(bool debug) {
        run = true;
        if(!in_stack.empty()) in_stack.erase(in_stack.begin(), in_stack.end());
        proc.clrFlags();
        proc.ip = 0;
        execute(debug);
    }
    
    void Code::stop() {
        run = false;
    }
    
    void Code::end() {
        run = false;
        proc.ip = 0;
         if(!in_stack.empty()) in_stack.erase(in_stack.begin(), in_stack.end());
        if(!stack.empty()) stack.erase(stack.begin(), stack.end());
    }
    
    void Code::pause() {
        run = false;
    }
    
    void Code::execute(bool debug) {
        while(run == true) {
            if(proc.ip >= 0) {
                if(debug == true)
                    printCurrent();
                procInstruct(instruct[proc.ip]);
                if(run == true && debug == true)
                    print();
                ++proc.ip;
                if(proc.ip > instruct.size()) {
                    run = false;
                    proc.ip = 0;
                    stream << "Program end reached without END, use END to terminate your program.\r\n";
                     if(!in_stack.empty()) in_stack.erase(in_stack.begin(), in_stack.end());
                    if(!stack.empty()) stack.erase(stack.begin(), stack.end());
                    break;
                }
            }
        }
    }
    
    
    void Code::cont() {
        if(proc.ip == 0) {
            stream << "You must run your program first with execute.\r\n";
            return;
        }
        run = true;
        execute();
    }
    
    void Code::step() {
        if(instruct.size()==0) return;
        if(proc.ip >= 0 && proc.ip < instruct.size()) {
            if(instruct[proc.ip].opcode == opc::END)
                procInstruct(instruct[proc.ip]);
            else {
                procInstruct(instruct[proc.ip++]);
            }
        } else {
            stream << "Program finished executing..\r\n";
            run = false;
            proc.ip = 0;
        }
    }
    
    
    void Code::printCurrent() {
        if(instruct.size()==0) return;
        if(proc.ip >= 0 && proc.ip < instruct.size())
        	stream << instruct[proc.ip];
    }
    
    void Code::reset() {
        if(!instruct.empty())
            instruct.erase(instruct.begin(), instruct.end());
        
        proc.clrFlags();
        
        if(!stack.empty())
            stack.erase(stack.begin(), stack.end());
        
        proc.reset();
        
        if(!in_stack.empty())
        	in_stack.erase(in_stack.begin(), in_stack.end());
    }
    
    void Code::reset_memory() {
        memset(mem, 0, sizeof(mem));
    }

    void Code::print() {
        stream << "{ ";
        proc.printRegisters();
        proc.printFlags();
        stream << "}\r\n";
    }
    
    void Code::procInstruct(icode::Instruction &i) {
        unsigned int op_code = static_cast<unsigned int>(i.opcode);
        if(op_code < static_cast<int>(icode::opc::NOTINC))
        	inst[op_code].call_back(*this);
    }
    
    
    uint8_t Code::peek(uint16_t address) const {
        return mem[address];
    }
    
    void Code::poke(uint16_t address, uint8_t value) {
        mem[address] = value;
    }
}