#ifndef BEAR_CPU_H
#define BEAR_CPU_H

#include "common.h"
#include "memory.h"

class CPU
{
public:
    explicit CPU(IMemoryAccessor* memory);

    void start();
    void reset();
private:
    enum STATUS_FLAGS
    {
        C = 1 << 0,
        Z = 1 << 1,
        I = 1 << 2,
        D = 1 << 3,
        B = 1 << 4,
        O = 1 << 6,
        N = 1 << 7,
    };

    uint8_t a;
    uint8_t x, y;

    uint16_t pc;

    uint8_t sp;

    IMemoryAccessor* _memory;

    // Stat flags
    uint8_t stat;

    int cycles;

    bool stop;

    void c(const bool _v) { _v ? (stat |= C) : stat &= ~C; }
    [[nodiscard]] bool c() const { return (stat & C) > 0; }

    void z(const bool _v) { _v ? (stat |= Z) : stat &= ~Z; }
    [[nodiscard]] bool z() const { return (stat & Z) > 0; }

    void i(const bool _v) { _v ? (stat |= I) : stat &= ~I; }
    [[nodiscard]] bool i() const { return (stat & I) > 0; }

    void d(const bool _v) { _v ? (stat |= D) : stat &= ~D; }
    [[nodiscard]] bool d() const { return (stat & D) > 0; }

    void b(const bool _v) { _v ? (stat |= B) : stat &= ~B; }
    [[nodiscard]] bool b() const { return (stat & B) > 0; }

    void o(const bool _v) { _v ? (stat |= O) : stat &= ~O; }
    [[nodiscard]] bool o() const { return (stat & O) > 0; }
    // END Stat flags

    void loop();

    [[nodiscard]] std::uint8_t readImm() const;
    [[nodiscard]] std::uint8_t readZp() const;
    [[nodiscard]] std::uint8_t readZpX() const;
    [[nodiscard]] std::uint8_t readAbs();
    [[nodiscard]] std::uint8_t readAbsX();
    [[nodiscard]] std::uint8_t readAbsY();
    [[nodiscard]] std::uint8_t readIdxInd();
    [[nodiscard]] std::uint8_t readIndIdx();

    void adc(std::uint8_t val);

    void setFlagsFromResult(std::uint16_t result);
};


#endif //BEAR_CPU_H