use crate::error::Error;
use crate::timers::CpuTimer;
use crate::memory::{Address, Addressable, AddressSpace};

use super::debugger::M68kDebugger;
use super::decode::{
    M68kDecoder,
    Instruction,
    Target,
    Size,
    Sign,
    Direction,
    Condition,
    ShiftDirection,
    ControlRegister,
    RegisterType,
    sign_extend_to_long
};


/*
pub trait Processor {
    fn reset();
    fn step();
}
*/


const FLAGS_ON_RESET: u16 = 0x2700;

pub const FLAGS_CARRY: u16 = 0x0001;
pub const FLAGS_OVERFLOW: u16 = 0x0002;
pub const FLAGS_ZERO: u16 = 0x0004;
pub const FLAGS_NEGATIVE: u16 = 0x0008;
pub const FLAGS_EXTEND: u16 = 0x0010;
pub const FLAGS_SUPERVISOR: u16 = 0x2000;
pub const FLAGS_TRACING: u16 = 0x8000;

pub const ERR_BUS_ERROR: u32 = 2;
pub const ERR_ADDRESS_ERROR: u32 = 3;
pub const ERR_ILLEGAL_INSTRUCTION: u32 = 4;


#[derive(Copy, Clone, Debug, PartialEq)]
pub enum Status {
    Init,
    Running,
    Stopped,
    Halted,
}

pub struct MC68010State {
    pub status: Status,

    pub pc: u32,
    pub sr: u16,
    pub d_reg: [u32; 8],
    pub a_reg: [u32; 7],
    pub msp: u32,
    pub usp: u32,

    pub vbr: u32,
}

impl MC68010State {
    pub fn new() -> MC68010State {
        MC68010State {
            status: Status::Init,

            pc: 0,
            sr: FLAGS_ON_RESET,
            d_reg: [0; 8],
            a_reg: [0; 7],
            msp: 0,
            usp: 0,

            vbr: 0,
        }
    }
}

pub struct MC68010 {
    pub state: MC68010State,
    pub decoder: M68kDecoder,
    pub debugger: M68kDebugger,
    pub timer: CpuTimer,
}

impl MC68010 {
    pub fn new() -> MC68010 {
        MC68010 {
            state: MC68010State::new(),
            decoder: M68kDecoder::new(0),
            debugger: M68kDebugger::new(),
            timer: CpuTimer::new(),
        }
    }

    pub fn dump_state(&self, space: &mut AddressSpace) {
        println!("Status: {:?}", self.state.status);
        println!("PC: {:#010x}", self.state.pc);
        println!("SR: {:#06x}", self.state.sr);
        for i in 0..7 {
            println!("D{}: {:#010x}        A{}:  {:#010x}", i, self.state.d_reg[i as usize], i, self.state.a_reg[i as usize]);
        }
        println!("D7: {:#010x}", self.state.d_reg[7]);
        println!("MSP: {:#010x}", self.state.msp);
        println!("USP: {:#010x}", self.state.usp);

        println!("Current Instruction: {:#010x} {:?}", self.decoder.start, self.decoder.instruction);
        println!("");
        space.dump_memory(self.state.msp as Address, 0x40);
        println!("");
    }

    pub fn reset(&mut self) {
        self.state = MC68010State::new();
        self.decoder = M68kDecoder::new(0);
        self.debugger = M68kDebugger::new();
    }

    pub fn is_running(&self) -> bool {
        self.state.status != Status::Stopped
    }

    pub fn init(&mut self, space: &mut AddressSpace) -> Result<(), Error> {
        println!("Initializing CPU");

        self.state.msp = space.read_beu32(0)?;
        self.state.pc = space.read_beu32(4)?;
        self.state.status = Status::Running;

        Ok(())
    }

    pub fn step(&mut self, space: &mut AddressSpace) -> Result<(), Error> {
        match self.state.status {
            Status::Init => self.init(space),
            Status::Stopped | Status::Halted => Err(Error::new("CPU stopped")),
            Status::Running => {
                let timer = self.timer.cycle.start();
                self.decode_next(space)?;
                self.execute_current(space)?;
                self.timer.cycle.end(timer);

                //if (self.timer.cycle.events % 500) == 0 {
                //    println!("{}", self.timer);
                //}

                Ok(())
            },
        }
    }

    pub fn exception(&mut self, space: &mut AddressSpace, number: u8) -> Result<(), Error> {
        let offset = (number as u16) << 2;
        self.push_word(space, offset)?;
        self.push_long(space, self.state.pc)?;
        self.push_word(space, self.state.sr)?;
        self.state.sr |= FLAGS_SUPERVISOR;
        self.state.sr &= !FLAGS_TRACING;
        self.state.pc = space.read_beu32((self.state.vbr + offset as u32) as Address)?;
        Ok(())
    }

    pub fn decode_next(&mut self, space: &mut AddressSpace) -> Result<(), Error> {
        self.check_breakpoints();

        let timer = self.timer.decode.start();
        self.decoder = M68kDecoder::decode_at(space, self.state.pc)?;
        self.timer.decode.end(timer);

        if self.debugger.use_tracing {
            // Print instruction bytes for debugging
            let ins_data: Result<String, Error> =
                (0..((self.decoder.end - self.decoder.start) / 2)).map(|offset|
                    Ok(format!("{:04x} ", space.read_beu16((self.decoder.start + (offset * 2)) as Address)?))
                ).collect();
            debug!("{:#010x}: {}\n\t{:?}\n", self.decoder.start, ins_data?, self.decoder.instruction);
        }

        if self.debugger.use_debugger {
            self.run_debugger(space);
        }

        self.state.pc = self.decoder.end;
        Ok(())
    }

    pub fn execute_current(&mut self, space: &mut AddressSpace) -> Result<(), Error> {
        let timer = self.timer.decode.start();
        match self.decoder.instruction {
            Instruction::ADD(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let (result, carry) = overflowing_add_sized(existing, value, size);
                match dest {
                    Target::DirectAReg(_) => { },
                    _ => self.set_compare_flags(result, size, carry, get_overflow(existing, value, result, size)),
                }
                self.set_target_value(space, dest, result, size)?;
            },
            Instruction::AND(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let result = get_value_sized(existing & value, size);
                self.set_target_value(space, dest, result, size)?;
                self.set_logic_flags(result, size);
            },
            Instruction::ANDtoCCR(value) => {
                self.state.sr = self.state.sr | value as u16;
            },
            Instruction::ANDtoSR(value) => {
                self.state.sr = self.state.sr | value;
            },
            Instruction::ASd(count, target, size, shift_dir) => {
                let count = self.get_target_value(space, count, size)? % 64;
                let mut pair = (self.get_target_value(space, target, size)?, false);
                let original = pair.0;
                for _ in 0..count {
                    pair = shift_operation(pair.0, size, shift_dir, true);
                }
                self.set_logic_flags(pair.0, size);
                if pair.1 {
                    self.state.sr |= FLAGS_EXTEND | FLAGS_CARRY;
                }
                if get_msb(pair.0, size) != get_msb(original, size) {
                    self.state.sr |= FLAGS_OVERFLOW;
                }
                self.set_target_value(space, target, pair.0, size)?;
            },
            Instruction::Bcc(cond, offset) => {
                let should_branch = self.get_current_condition(cond);
                if should_branch {
                    self.state.pc = (self.decoder.start + 2).wrapping_add(offset as u32);
                }
            },
            Instruction::BRA(offset) => {
                self.state.pc = (self.decoder.start + 2).wrapping_add(offset as u32);
            },
            Instruction::BSR(offset) => {
                self.push_long(space, self.state.pc)?;
                let sp = *self.get_stack_pointer_mut();
                self.debugger.stack_tracer.push_return(sp);
                self.state.pc = (self.decoder.start + 2).wrapping_add(offset as u32);
            },
            Instruction::BTST(bitnum, target, size) => {
                let bitnum = self.get_target_value(space, bitnum, Size::Byte)?;
                let value = self.get_target_value(space, target, size)?;
                self.set_bit_test_flags(value, bitnum, size);
            },
            Instruction::BCHG(bitnum, target, size) => {
                let bitnum = self.get_target_value(space, bitnum, Size::Byte)?;
                let mut value = self.get_target_value(space, target, size)?;
                let mask = self.set_bit_test_flags(value, bitnum, size);
                value = (value & !mask) | (!(value & mask) & mask);
                self.set_target_value(space, target, value, size)?;
            },
            Instruction::BCLR(bitnum, target, size) => {
                let bitnum = self.get_target_value(space, bitnum, Size::Byte)?;
                let mut value = self.get_target_value(space, target, size)?;
                let mask = self.set_bit_test_flags(value, bitnum, size);
                value = value & !mask;
                self.set_target_value(space, target, value, size)?;
            },
            Instruction::BSET(bitnum, target, size) => {
                let bitnum = self.get_target_value(space, bitnum, Size::Byte)?;
                let mut value = self.get_target_value(space, target, size)?;
                let mask = self.set_bit_test_flags(value, bitnum, size);
                value = value | mask;
                self.set_target_value(space, target, value, size)?;
            },
            Instruction::CLR(target, size) => {
                self.set_target_value(space, target, 0, size)?;
                // Clear flags except Zero flag
                self.state.sr = (self.state.sr & 0xFFF0) | FLAGS_ZERO;
            },
            Instruction::CMP(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let (result, carry) = overflowing_sub_sized(existing, value, size);
                self.set_compare_flags(result, size, carry, get_overflow(existing, value, result, size));
            },
            Instruction::CMPA(src, reg, size) => {
                let value = sign_extend_to_long(self.get_target_value(space, src, size)?, size) as u32;
                let existing = *self.get_a_reg_mut(reg);
                let (result, carry) = overflowing_sub_sized(existing, value, Size::Long);
                self.set_compare_flags(result, Size::Long, carry, get_overflow(existing, value, result, Size::Long));
            },
            Instruction::DBcc(cond, reg, offset) => {
                let condition_true = self.get_current_condition(cond);
                if !condition_true {
                    let next = (get_value_sized(self.state.d_reg[reg as usize], Size::Word) as u16) as i16 - 1;
                    set_value_sized(&mut self.state.d_reg[reg as usize], next as u32, Size::Word);
                    if next != -1 {
                        self.state.pc = (self.decoder.start + 2).wrapping_add(offset as u32);
                    }
                }
            },
            Instruction::DIV(src, dest, size, sign) => {
                if size == Size::Long {
                    return Err(Error::new("Unsupported multiplication size"));
                }

                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, Size::Long)?;
                let result = match sign {
                    Sign::Signed => ((existing as i16 % value as i16) as u32) << 16 | (0xFFFF & (existing as i16 / value as i16) as u32),
                    Sign::Unsigned => ((existing as u16 % value as u16) as u32) << 16 | (0xFFFF & (existing as u16 / value as u16) as u32),
                };
                self.set_target_value(space, dest, result, Size::Long)?;
            },
            Instruction::EOR(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let result = get_value_sized(existing ^ value, size);
                self.set_target_value(space, dest, result, size)?;
                self.set_logic_flags(result, size);
            },
            Instruction::EORtoCCR(value) => {
                self.state.sr = self.state.sr ^ value as u16;
            },
            Instruction::EORtoSR(value) => {
                self.state.sr = self.state.sr ^ value;
            },
            //Instruction::EXG(Target, Target) => {
            //},
            Instruction::EXT(reg, size) => {
                let byte = (self.state.d_reg[reg as usize] as u8) as i8;
                let result = match size {
                    Size::Byte => (byte as u8) as u32,
                    Size::Word => ((byte as i16) as u16) as u32,
                    Size::Long => (byte as i32) as u32,
                };
                set_value_sized(&mut self.state.d_reg[reg as usize], result, size);
                self.set_logic_flags(result, size);
            },
            //Instruction::ILLEGAL => {
            //},
            Instruction::JMP(target) => {
                self.state.pc = self.get_target_address(target)?;
            },
            Instruction::JSR(target) => {
                self.push_long(space, self.state.pc)?;
                let sp = *self.get_stack_pointer_mut();
                self.debugger.stack_tracer.push_return(sp);
                self.state.pc = self.get_target_address(target)?;
            },
            Instruction::LEA(target, reg) => {
                let value = self.get_target_address(target)?;
                let addr = self.get_a_reg_mut(reg);
                *addr = value;
            },
            Instruction::LINK(reg, offset) => {
                let value = *self.get_a_reg_mut(reg);
                self.push_long(space, value)?;
                let sp = *self.get_stack_pointer_mut();
                let addr = self.get_a_reg_mut(reg);
                *addr = sp;
                *self.get_stack_pointer_mut() = sp.wrapping_add((offset as i32) as u32);
            },
            Instruction::LSd(count, target, size, shift_dir) => {
                let count = self.get_target_value(space, count, size)? % 64;
                let mut pair = (self.get_target_value(space, target, size)?, false);
                for _ in 0..count {
                    pair = shift_operation(pair.0, size, shift_dir, false);
                }
                self.set_logic_flags(pair.0, size);
                if pair.1 {
                    self.state.sr |= FLAGS_EXTEND | FLAGS_CARRY;
                }
                self.set_target_value(space, target, pair.0, size)?;
            },
            Instruction::MOVE(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                self.set_logic_flags(value, size);
                self.set_target_value(space, dest, value, size)?;
            },
            Instruction::MOVEA(src, reg, size) => {
                let value = self.get_target_value(space, src, size)?;
                let value = sign_extend_to_long(value, size) as u32;
                let addr = self.get_a_reg_mut(reg);
                *addr = value;
            },
            Instruction::MOVEfromSR(target) => {
                self.set_target_value(space, target, self.state.sr as u32, Size::Word)?;
            },
            Instruction::MOVEtoSR(target) => {
                self.state.sr = self.get_target_value(space, target, Size::Word)? as u16;
            },
            Instruction::MOVEtoCCR(target) => {
                let value = self.get_target_value(space, target, Size::Word)? as u16;
                self.state.sr = (self.state.sr & 0xFF00) | (value & 0x00FF);
            },
            Instruction::MOVEC(target, control_reg, dir) => {
                match dir {
                    Direction::FromTarget => {
                        let value = self.get_target_value(space, target, Size::Long)?;
                        let addr = self.get_control_reg_mut(control_reg);
                        *addr = value;
                    },
                    Direction::ToTarget => {
                        let addr = self.get_control_reg_mut(control_reg);
                        let value = *addr;
                        self.set_target_value(space, target, value, Size::Long)?;
                    },
                }
            },
            Instruction::MOVEUSP(target, dir) => {
                match dir {
                    Direction::ToTarget => self.set_target_value(space, target, self.state.usp, Size::Long)?,
                    Direction::FromTarget => { self.state.usp = self.get_target_value(space, target, Size::Long)?; },
                }
            },
            Instruction::MOVEM(target, size, dir, mask) => {
                // TODO moving words requires a sign extension to 32 bits
                if size != Size::Long { return Err(Error::new("Unsupported size in MOVEM instruction")); }

                let mut addr = self.get_target_address(target)?;
                if dir == Direction::ToTarget {
                    let mut mask = mask;
                    for i in (0..8).rev() {
                        if (mask & 0x01) != 0 {
                            let value = *self.get_a_reg_mut(i);
                            addr -= size.in_bytes();
                            set_address_sized(space, addr as Address, value, size);
                        }
                        mask >>= 1;
                    }
                    for i in (0..8).rev() {
                        if (mask & 0x01) != 0 {
                            addr -= size.in_bytes();
                            set_address_sized(space, addr as Address, self.state.d_reg[i], size);
                        }
                        mask >>= 1;
                    }
                } else {
                    let mut mask = mask;
                    for i in 0..8 {
                        if (mask & 0x01) != 0 {
                            self.state.d_reg[i] = get_address_sized(space, addr as Address, size)?;
                            addr += size.in_bytes();
                        }
                        mask >>= 1;
                    }
                    for i in 0..8 {
                        if (mask & 0x01) != 0 {
                            *self.get_a_reg_mut(i) = get_address_sized(space, addr as Address, size)?;
                            addr += size.in_bytes();
                        }
                        mask >>= 1;
                    }
                }

                // If it was Post-Inc/Pre-Dec target, then update the value
                match target {
                    Target::IndirectARegInc(reg) | Target::IndirectARegDec(reg) => {
                        let a_reg_mut = self.get_a_reg_mut(reg);
                        *a_reg_mut = addr;
                    }
                    _ => { },
                }
            },
            Instruction::MOVEQ(data, reg) => {
                let value = sign_extend_to_long(data as u32, Size::Byte) as u32;
                self.state.d_reg[reg as usize] = value;
                self.set_logic_flags(value, Size::Long);
            },
            Instruction::MUL(src, dest, size, sign) => {
                if size == Size::Long {
                    return Err(Error::new("Unsupported multiplication size"));
                }

                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let result = match sign {
                    Sign::Signed => (sign_extend_to_long(existing, Size::Word) * sign_extend_to_long(value, Size::Word)) as u32,
                    Sign::Unsigned => existing as u32 * value as u32,
                };
                self.set_target_value(space, dest, result, Size::Long)?;
            },
            //Instruction::NBCD(Target) => {
            //},
            Instruction::NEG(target, size) => {
                let original = self.get_target_value(space, target, size)?;
                let (value, _) = (0 as u32).overflowing_sub(original);
                self.set_target_value(space, target, value, size);
                self.set_compare_flags(value, size, value != 0, get_overflow(0, original, value, size));
            },
            //Instruction::NEGX(Target, Size) => {
            //},
            Instruction::NOP => { },
            Instruction::NOT(target, size) => {
                let mut value = self.get_target_value(space, target, size)?;
                value = get_value_sized(!value, size);
                self.set_target_value(space, target, value, size)?;
                self.set_logic_flags(value, size);
            },
            Instruction::OR(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let result = get_value_sized(existing | value, size);
                self.set_target_value(space, dest, result, size)?;
                self.set_logic_flags(result, size);
            },
            Instruction::ORtoCCR(value) => {
                self.state.sr = self.state.sr | value as u16;
            },
            Instruction::ORtoSR(value) => {
                self.state.sr = self.state.sr | value;
            },
            Instruction::PEA(target) => {
                let value = self.get_target_address(target)?;
                self.push_long(space, value)?;
            },
            //Instruction::RESET => {
            //},
            Instruction::ROd(count, target, size, shift_dir) => {
                let count = self.get_target_value(space, count, size)? % 64;
                let mut pair = (self.get_target_value(space, target, size)?, false);
                for _ in 0..count {
                    pair = rotate_operation(pair.0, size, shift_dir);
                }
                self.set_logic_flags(pair.0, size);
                if pair.1 {
                    self.state.sr |= FLAGS_CARRY;
                }
                self.set_target_value(space, target, pair.0, size)?;
            },
            //Instruction::ROXd(Target, Target, Size, ShiftDirection) => {
            //},
            Instruction::RTE => {
                self.state.sr = self.pop_word(space)?;
                self.state.pc = self.pop_long(space)?;
                let _ = self.pop_word(space)?;
            },
            //Instruction::RTR => {
            //},
            Instruction::RTS => {
                self.debugger.stack_tracer.pop_return();
                self.state.pc = self.pop_long(space)?;
            },
            Instruction::Scc(cond, target) => {
                let condition_true = self.get_current_condition(cond);
                if condition_true {
                    self.set_target_value(space, target, 0xFF, Size::Byte);
                } else {
                    self.set_target_value(space, target, 0x00, Size::Byte);
                }
            },
            Instruction::STOP(flags) => {
                self.state.sr = flags;
                self.state.status = Status::Stopped;
            },
            Instruction::SUB(src, dest, size) => {
                let value = self.get_target_value(space, src, size)?;
                let existing = self.get_target_value(space, dest, size)?;
                let (result, carry) = overflowing_sub_sized(existing, value, size);
                match dest {
                    Target::DirectAReg(_) => { },
                    _ => self.set_compare_flags(result, size, carry, get_overflow(existing, value, result, size)),
                }
                self.set_target_value(space, dest, result, size)?;
            },
            Instruction::SWAP(reg) => {
                let value = self.state.d_reg[reg as usize];
                self.state.d_reg[reg as usize] = ((value & 0x0000FFFF) << 16) | ((value & 0xFFFF0000) >> 16);
            },
            //Instruction::TAS(Target) => {
            //},
            Instruction::TST(target, size) => {
                let value = self.get_target_value(space, target, size)?;
                self.set_logic_flags(value, size);
            },
            Instruction::TRAP(number) => {
                self.exception(space, 32 + number)?;
            },
            Instruction::TRAPV => {
                if self.get_flag(FLAGS_OVERFLOW) {
                    self.exception(space, 7)?;
                }
            },
            Instruction::UNLK(reg) => {
                let value = *self.get_a_reg_mut(reg);
                *self.get_stack_pointer_mut() = value;
                let new_value = self.pop_long(space)?;
                let addr = self.get_a_reg_mut(reg);
                *addr = new_value;
            },
            _ => { return Err(Error::new("Unsupported instruction")); },
        }

        self.timer.execute.end(timer);
        Ok(())
    }

    fn push_word(&mut self, space: &mut AddressSpace, value: u16) -> Result<(), Error> {
        let reg = self.get_stack_pointer_mut();
        *reg -= 2;
        space.write_beu16(*reg as Address, value)
    }

    fn pop_word(&mut self, space: &mut AddressSpace) -> Result<u16, Error> {
        let reg = self.get_stack_pointer_mut();
        let value = space.read_beu16(*reg as Address)?;
        *reg += 2;
        Ok(value)
    }

    fn push_long(&mut self, space: &mut AddressSpace, value: u32) -> Result<(), Error> {
        let reg = self.get_stack_pointer_mut();
        *reg -= 4;
        space.write_beu32(*reg as Address, value)
    }

    fn pop_long(&mut self, space: &mut AddressSpace) -> Result<u32, Error> {
        let reg = self.get_stack_pointer_mut();
        let value = space.read_beu32(*reg as Address)?;
        *reg += 4;
        Ok(value)
    }

    pub fn get_target_value(&mut self, space: &mut AddressSpace, target: Target, size: Size) -> Result<u32, Error> {
        match target {
            Target::Immediate(value) => Ok(value),
            Target::DirectDReg(reg) => Ok(get_value_sized(self.state.d_reg[reg as usize], size)),
            Target::DirectAReg(reg) => Ok(get_value_sized(*self.get_a_reg_mut(reg), size)),
            Target::IndirectAReg(reg) => get_address_sized(space, *self.get_a_reg_mut(reg) as Address, size),
            Target::IndirectARegInc(reg) => {
                let addr = self.get_a_reg_mut(reg);
                let result = get_address_sized(space, *addr as Address, size);
                *addr += size.in_bytes();
                result
            },
            Target::IndirectARegDec(reg) => {
                let addr = self.get_a_reg_mut(reg);
                *addr -= size.in_bytes();
                get_address_sized(space, *addr as Address, size)
            },
            Target::IndirectARegOffset(reg, offset) => {
                let addr = self.get_a_reg_mut(reg);
                get_address_sized(space, (*addr).wrapping_add(offset as u32) as Address, size)
            },
            Target::IndirectARegXRegOffset(reg, rtype, xreg, offset, target_size) => {
                let reg_offset = sign_extend_to_long(self.get_x_reg_value(rtype, xreg), target_size);
                let addr = self.get_a_reg_mut(reg);
                get_address_sized(space, (*addr).wrapping_add(reg_offset as u32).wrapping_add(offset as u32) as Address, size)
            },
            Target::IndirectMemory(addr) => {
                get_address_sized(space, addr as Address, size)
            },
            Target::IndirectPCOffset(offset) => {
                get_address_sized(space, (self.decoder.start + 2).wrapping_add(offset as u32) as Address, size)
            },
            Target::IndirectPCXRegOffset(rtype, xreg, offset, target_size) => {
                let reg_offset = sign_extend_to_long(self.get_x_reg_value(rtype, xreg), target_size);
                get_address_sized(space, (self.decoder.start + 2).wrapping_add(reg_offset as u32).wrapping_add(offset as u32) as Address, size)
            },
        }
    }

    pub fn set_target_value(&mut self, space: &mut AddressSpace, target: Target, value: u32, size: Size) -> Result<(), Error> {
        match target {
            Target::DirectDReg(reg) => {
                set_value_sized(&mut self.state.d_reg[reg as usize], value, size);
            },
            Target::DirectAReg(reg) => {
                set_value_sized(self.get_a_reg_mut(reg), value, size);
            },
            Target::IndirectAReg(reg) => {
                set_address_sized(space, *self.get_a_reg_mut(reg) as Address, value, size)?;
            },
            Target::IndirectARegInc(reg) => {
                let addr = self.get_a_reg_mut(reg);
                set_address_sized(space, *addr as Address, value, size)?;
                *addr += size.in_bytes();
            },
            Target::IndirectARegDec(reg) => {
                let addr = self.get_a_reg_mut(reg);
                *addr -= size.in_bytes();
                set_address_sized(space, *addr as Address, value, size)?;
            },
            Target::IndirectARegOffset(reg, offset) => {
                let addr = self.get_a_reg_mut(reg);
                set_address_sized(space, (*addr).wrapping_add(offset as u32) as Address, value, size)?;
            },
            Target::IndirectARegXRegOffset(reg, rtype, xreg, offset, target_size) => {
                let reg_offset = sign_extend_to_long(self.get_x_reg_value(rtype, xreg), target_size);
                let addr = self.get_a_reg_mut(reg);
                set_address_sized(space, (*addr).wrapping_add(reg_offset as u32).wrapping_add(offset as u32) as Address, value, size)?;
            },
            Target::IndirectMemory(addr) => {
                set_address_sized(space, addr as Address, value, size)?;
            },
            _ => return Err(Error::new(&format!("Unimplemented addressing target: {:?}", target))),
        }
        Ok(())
    }

    pub fn get_target_address(&mut self, target: Target) -> Result<u32, Error> {
        let addr = match target {
            Target::IndirectAReg(reg) | Target::IndirectARegInc(reg) | Target::IndirectARegDec(reg) => *self.get_a_reg_mut(reg),
            Target::IndirectARegOffset(reg, offset) => {
                let addr = self.get_a_reg_mut(reg);
                (*addr).wrapping_add(offset as u32)
            },
            Target::IndirectARegXRegOffset(reg, rtype, xreg, offset, target_size) => {
                let reg_offset = sign_extend_to_long(self.get_x_reg_value(rtype, xreg), target_size);
                let addr = self.get_a_reg_mut(reg);
                (*addr).wrapping_add(reg_offset as u32).wrapping_add(offset as u32)
            },
            Target::IndirectMemory(addr) => {
                addr
            },
            Target::IndirectPCOffset(offset) => {
                (self.decoder.start + 2).wrapping_add(offset as u32)
            },
            Target::IndirectPCXRegOffset(rtype, xreg, offset, target_size) => {
                let reg_offset = sign_extend_to_long(self.get_x_reg_value(rtype, xreg), target_size);
                (self.decoder.start + 2).wrapping_add(reg_offset as u32).wrapping_add(offset as u32)
            },
            _ => return Err(Error::new(&format!("Invalid addressing target: {:?}", target))),
        };
        Ok(addr)
    }

    fn get_control_reg_mut(&mut self, control_reg: ControlRegister) -> &mut u32 {
        match control_reg {
            ControlRegister::VBR => &mut self.state.vbr,
        }
    }

    #[inline(always)]
    fn get_stack_pointer_mut(&mut self) -> &mut u32 {
        if self.is_supervisor() { &mut self.state.msp } else { &mut self.state.usp }
    }

    #[inline(always)]
    fn get_a_reg_mut(&mut self, reg: u8) -> &mut u32 {
        if reg == 7 {
            if self.is_supervisor() { &mut self.state.msp } else { &mut self.state.usp }
        } else {
            &mut self.state.a_reg[reg as usize]
        }
    }

    fn get_x_reg_value(&self, rtype: RegisterType, reg: u8) -> u32 {
        match rtype {
            RegisterType::Data => self.state.d_reg[reg as usize],
            RegisterType::Address => self.state.a_reg[reg as usize],
        }
    }

    fn is_supervisor(&self) -> bool {
        self.state.sr & FLAGS_SUPERVISOR != 0
    }

    fn get_flag(&self, flag: u16) -> bool {
        if (self.state.sr & flag) == 0 {
            false
        } else {
            true
        }
    }

    fn set_flag(&mut self, flag: u16, value: bool) {
        self.state.sr = (self.state.sr & !flag) | (if value { flag } else { 0 });
    }

    fn set_compare_flags(&mut self, value: u32, size: Size, carry: bool, overflow: bool) {
        let value = sign_extend_to_long(value, size);

        let mut flags = 0x0000;
        if value < 0 {
            flags |= FLAGS_NEGATIVE
        }
        if value == 0 {
            flags |= FLAGS_ZERO
        }
        if carry {
            flags |= FLAGS_CARRY;
        }
        if overflow {
            flags |= FLAGS_OVERFLOW;
        }
        self.state.sr = (self.state.sr & 0xFFF0) | flags;
    }

    fn set_logic_flags(&mut self, value: u32, size: Size) {
        let mut flags = 0x0000;
        if get_msb(value, size) {
            flags |= FLAGS_NEGATIVE;
        }
        if value == 0 {
            flags |= FLAGS_ZERO
        }
        self.state.sr = (self.state.sr & 0xFFF0) | flags;
    }

    fn set_bit_test_flags(&mut self, value: u32, bitnum: u32, size: Size) -> u32 {
        let mask = 0x1 << (bitnum % size.in_bits());
        let zeroflag = if (value & mask) == 0 { FLAGS_ZERO } else { 0 };
        self.state.sr = (self.state.sr & !FLAGS_ZERO) | zeroflag;
        mask
    }


    fn get_current_condition(&self, cond: Condition) -> bool {
        match cond {
            Condition::True => true,
            Condition::False => false,
            Condition::High => !self.get_flag(FLAGS_CARRY) && !self.get_flag(FLAGS_ZERO),
            Condition::LowOrSame => self.get_flag(FLAGS_CARRY) || self.get_flag(FLAGS_ZERO),
            Condition::CarryClear => !self.get_flag(FLAGS_CARRY),
            Condition::CarrySet => self.get_flag(FLAGS_CARRY),
            Condition::NotEqual => !self.get_flag(FLAGS_ZERO),
            Condition::Equal => self.get_flag(FLAGS_ZERO),
            Condition::OverflowClear => !self.get_flag(FLAGS_OVERFLOW),
            Condition::OverflowSet => self.get_flag(FLAGS_OVERFLOW),
            Condition::Plus => !self.get_flag(FLAGS_NEGATIVE),
            Condition::Minus => self.get_flag(FLAGS_NEGATIVE),
            Condition::GreaterThanOrEqual => (self.get_flag(FLAGS_NEGATIVE) && self.get_flag(FLAGS_OVERFLOW)) || (!self.get_flag(FLAGS_NEGATIVE) && !self.get_flag(FLAGS_OVERFLOW)),
            Condition::LessThan => (self.get_flag(FLAGS_NEGATIVE) && !self.get_flag(FLAGS_OVERFLOW)) || (!self.get_flag(FLAGS_NEGATIVE) && self.get_flag(FLAGS_OVERFLOW)),
            Condition::GreaterThan =>
                (self.get_flag(FLAGS_NEGATIVE) && self.get_flag(FLAGS_OVERFLOW) && !self.get_flag(FLAGS_ZERO))
                || (!self.get_flag(FLAGS_NEGATIVE) && !self.get_flag(FLAGS_OVERFLOW) && !self.get_flag(FLAGS_ZERO)),
            Condition::LessThanOrEqual =>
                self.get_flag(FLAGS_ZERO)
                || (self.get_flag(FLAGS_NEGATIVE) && !self.get_flag(FLAGS_OVERFLOW))
                || (!self.get_flag(FLAGS_NEGATIVE) && self.get_flag(FLAGS_OVERFLOW)),
        }
    }
}


fn overflowing_add_sized(operand1: u32, operand2: u32, size: Size) -> (u32, bool) {
    match size {
        Size::Byte => {
            let (result, carry) = (operand1 as u8).overflowing_add(operand2 as u8);
            (result as u32, carry)
        },
        Size::Word => {
            let (result, carry) = (operand1 as u16).overflowing_add(operand2 as u16);
            (result as u32, carry)
        },
        Size::Long => operand1.overflowing_add(operand2),
    }
}

fn overflowing_sub_sized(operand1: u32, operand2: u32, size: Size) -> (u32, bool) {
    match size {
        Size::Byte => {
            let (result, carry) = (operand1 as u8).overflowing_sub(operand2 as u8);
            (result as u32, carry)
        },
        Size::Word => {
            let (result, carry) = (operand1 as u16).overflowing_sub(operand2 as u16);
            (result as u32, carry)
        },
        Size::Long => operand1.overflowing_sub(operand2),
    }
}

fn shift_operation(value: u32, size: Size, dir: ShiftDirection, arithmetic: bool) -> (u32, bool) {
    match dir {
        ShiftDirection::Left => {
            let bit = get_msb(value, size);
            match size {
                Size::Byte => (((value as u8) << 1) as u32, bit),
                Size::Word => (((value as u16) << 1) as u32, bit),
                Size::Long => ((value << 1) as u32, bit),
            }
        },
        ShiftDirection::Right => {
            let mask = if arithmetic { get_msb_mask(value, size) } else { 0 };
            ((value >> 1) | mask, (value & 0x1) != 0)
        },
    }
}

fn rotate_operation(value: u32, size: Size, dir: ShiftDirection) -> (u32, bool) {
    match dir {
        ShiftDirection::Left => {
            let bit = get_msb(value, size);
            let mask = if bit { 0x01 } else { 0x00 };
            match size {
                Size::Byte => (mask | ((value as u8) << 1) as u32, bit),
                Size::Word => (mask | ((value as u16) << 1) as u32, bit),
                Size::Long => (mask | (value << 1) as u32, bit),
            }
        },
        ShiftDirection::Right => {
            let bit = if (value & 0x01) != 0 { true } else { false };
            let mask = if bit { get_msb_mask(0xffffffff, size) } else { 0x0 };
            ((value >> 1) | mask, bit)
        },
    }
}


fn get_value_sized(value: u32, size: Size) -> u32 {
    match size {
        Size::Byte => { 0x000000FF & value },
        Size::Word => { 0x0000FFFF & value },
        Size::Long => { value },
    }
}

fn get_address_sized(space: &mut AddressSpace, addr: Address, size: Size) -> Result<u32, Error> {
    match size {
        Size::Byte => space.read_u8(addr).map(|value| value as u32),
        Size::Word => space.read_beu16(addr).map(|value| value as u32),
        Size::Long => space.read_beu32(addr),
    }
}

fn set_value_sized(addr: &mut u32, value: u32, size: Size) {
    match size {
        Size::Byte => { *addr = (*addr & 0xFFFFFF00) | (0x000000FF & value); }
        Size::Word => { *addr = (*addr & 0xFFFF0000) | (0x0000FFFF & value); }
        Size::Long => { *addr = value; }
    }
}

fn set_address_sized(space: &mut AddressSpace, addr: Address, value: u32, size: Size) -> Result<(), Error> {
    match size {
        Size::Byte => space.write_u8(addr, value as u8),
        Size::Word => space.write_beu16(addr, value as u16),
        Size::Long => space.write_beu32(addr, value),
    }
}

fn get_overflow(operand1: u32, operand2: u32, result: u32, size: Size) -> bool {
    let msb1 = get_msb(operand1, size);
    let msb2 = get_msb(operand2, size);
    let msb_res = get_msb(result, size);

    msb1 && msb2 && !msb_res
}

fn get_msb(value: u32, size: Size) -> bool {
    match size {
        Size::Byte => (value & 0x00000080) != 0,
        Size::Word => (value & 0x00008000) != 0,
        Size::Long => (value & 0x80000000) != 0,
    }
}

fn get_msb_mask(value: u32, size: Size) -> u32 {
    match size {
        Size::Byte => value & 0x00000080,
        Size::Word => value & 0x00008000,
        Size::Long => value & 0x80000000,
    }
}