type nixbpe = {
  n : int;
  i : int;
  x : int;
  b : int;
  p : int;
  e : int
}

(*kreiramo začetno stanje -> TODO prestavi v main*)
let regs = Processor.{a = 0; x = 0; l = 0; b = 0; s = 0; t = 0; f = 0.0; pc = 0; sw = 0}
let memSize = 1 lsl 20 (*2^20*)
let memory = Bytes.make memSize '\x00' (*mutbale kos pomnilnika velikosti memSize*)
let state = Processor.{regs; memory}


(*----Funkcije izvajalnika----*)
(*TODO - brali bomo vedno relativno od začetka instrukcije, PC bomo na koncu ukaza povečali za pravo velikost!*)

(*funkcije za javljanje napak*)
let notImplemented (mnemonic : string) = Printf.printf "mnemonic %s is not implemented!\n" mnemonic
let invalidOpcode (opcode : int) = Printf.printf "opcode %d is invalid!\n" opcode
let invalidAdressing () = Printf.printf "invalid adressing!\n"




(*beri drugi byte ukaza formata 2 in vrni r1 in r2, kot int njunih vrednosti (reg a -> 1, reg x -> 2 ...)*)
let readR1R2 (state : Processor.state) : (int * int) =
  let byte2 = Char.code (Processor.readMem state 1) in 
  let highNibble = (byte2 land 0xF0) lsr 4 in (*pridobi prvi nibble*)
  let lowNibble = byte2 land 0x0F in (*pridobi drugi nibble*)
  (highNibble, lowNibble)

(*preberi byta 1 in 2 in dobi nixbpe bite*)
let getNIXBPE (state : Processor.state) : nixbpe =
  let byte1 = Char.code (Processor.readMem state 0) in 
  let byte2 = Char.code (Processor.readMem state 1) in 
  {n = (byte1 lsr 1) land 1;
   i = byte1 land 1;
   x = (byte2 lsr 7) land 1;
   b = (byte2 lsr 6) land 1;
   p = (byte2 lsr 5) land 1;
   e = (byte2 lsr 4) land 1;}


(*dobi disp iz tipa ukaza 3*)
(*TODO pretvori v negativno število glede na nxibpe*)
let getDisp (state : Processor.state) : int = 
  let byte2 = Char.code (Processor.readMem state 1) in 
  let byte3 = Char.code (Processor.readMem state 2) in
  let disp_high = byte2 land 0x0F in
  let disp = (disp_high lsl 8) lor byte3 in 
  disp

(*dobi address iz tip ukaza 4*)
(*TODO preveri ali mores paziti negativnost*)
let getAddress (state : Processor.state) : int =
  let byte2 = Char.code (Processor.readMem state 1) in 
  let byte3 = Char.code (Processor.readMem state 2) in
  let byte4 = Char.code (Processor.readMem state 3) in

  let addr_highest = byte2 land 0x0F in
  let addr_high = (addr_highest lsl 8) lor byte3 in
  let address = (addr_high lsl 8) lor byte4 in 
  address

  let getOperand (state : Processor.state) (nixbpe : nixbpe) (disp : int) : int = 
    let ea =
      if nixbpe.b = 1 && nixbpe.p = 0 then state.regs.b + disp (*B relativno*)
      else if nixbpe.p = 1 && nixbpe.b = 0 then state.regs.pc + disp (*PC relativno*)
      else disp (*direktno*)
    in
    let ea = if nixbpe.x = 1 then ea + state.regs.x else ea in (*+ (X) po potrebi*)
    (*pridobi operand*)
    let value =
      if nixbpe.n = 1 && nixbpe.i = 1 then Processor.readMemAddr state ea (*direktno*)
      else if nixbpe.n = 0 && nixbpe.i = 1 then disp  (* immediate value *)
      else if nixbpe.n = 1 && nixbpe.i = 0 then Processor.readMemAddr state (Processor.readMemAddr state ea)  (* indirect *)
      else failwith "Invalid addressing mode"
    in
    value

(*execute format 1*)
let executeFormat1 (state : Processor.state) (mnemonic : OpcodeTable.mnemonic) : unit =
  Processor.pcIncrement state 1;
  match mnemonic with
  | FIX -> IzvajalnikF1.fix state
  | FLOAT -> IzvajalnikF1.floatF state
  | HIO -> notImplemented "HIO"
  | NORM -> notImplemented "NORM"
  | SIO -> notImplemented "SIO"
  | TIO -> notImplemented "TIO"
  |_ -> failwith ("Mnemonic" ^  (OpcodeTable.string_of_mnemonic mnemonic) ^ "falsely flaged as format 1")



(*execute format 2*)
let executeFormat2 (state: Processor.state) (mnemonic : OpcodeTable.mnemonic) : unit =
  let (r1, r2) = readR1R2 state in 
  Processor.pcIncrement state 2;
  match mnemonic with 
  | ADDR -> IzvajalnikF2.addr state r1 r2
  | CLEAR -> IzvajalnikF2.clear state r1
  | COMPR -> IzvajalnikF2.compr state r1 r2
  | DIVR -> IzvajalnikF2.divr state r1 r2
  | MULR -> IzvajalnikF2.mulr state r1 r2
  | RMO -> IzvajalnikF2.rmo state r1 r2
  | SHIFTL -> IzvajalnikF2.shiftl state r1 r2
  | SHIFTR -> IzvajalnikF2.shiftr state r1 r2
  | SUBR -> IzvajalnikF2.subr state r1 r2
  | SVC -> notImplemented "F2"
  | TIXR -> IzvajalnikF2.tixr state r1
  |_ -> failwith ("Mnemonic" ^  (OpcodeTable.string_of_mnemonic mnemonic) ^ "falsely flaged as format 2")



(*execute Format 3*)
let executeFormat3 (state : Processor.state) (nixbpe : nixbpe) (mnemonic: OpcodeTable.mnemonic): unit = 
  let disp = getDisp state in
  let operand = getOperand state nixbpe disp in
  Processor.pcIncrement state 3; (*povecamo pc pred izvedbo ukaza*)
  match mnemonic with
  | ADD -> IzvajalnikF3.add state operand
  | ADDF -> notImplemented "ADDF3"
  | AND -> IzvajalnikF3.andF state operand
  | COMP -> IzvajalnikF3.comp state operand
  | COMPF -> notImplemented "COMPF3"
  | DIV -> IzvajalnikF3.div state operand
  | MUL -> IzvajalnikF3.mul state operand
  | OR -> IzvajalnikF3.orF state operand
  | SUB -> IzvajalnikF3.sub state operand
  | SUBF -> notImplemented "SUBF3"
  | TD -> notImplemented "TD3"
  | WD -> notImplemented "WD3"

  (* Jump / subroutine *)
  | J -> IzvajalnikF3.j state operand
  | JEQ -> IzvajalnikF3.jeq state operand
  | JGT -> IzvajalnikF3.jgt state operand
  | JLT -> IzvajalnikF3.jlt state operand
  | JSUB -> IzvajalnikF3.jsub state operand
  | RSUB -> IzvajalnikF3.rsub state operand

  (* Load/store *)
  | LDA -> IzvajalnikF3.lda state operand
  | LDB -> IzvajalnikF3.ldb state operand
  | LDCH -> notImplemented "LDCH3"
  | LDF -> notImplemented "LDF3"
  | LDL -> IzvajalnikF3.ldl state operand
  | LDS -> IzvajalnikF3.lds state operand
  | LDT -> IzvajalnikF3.ldt state operand
  | LDX -> IzvajalnikF3.ldx state operand
  | LPS -> notImplemented "LPS4"
  | STA -> IzvajalnikF3.sta state operand
  | STB -> IzvajalnikF3.stb state operand
  | STCH -> notImplemented "STCH4"
  | STF -> notImplemented "STF4"
  | STL -> IzvajalnikF3.stl state operand
  | STS -> IzvajalnikF3.sts state operand
  | STSW -> IzvajalnikF3.stsw state operand
  | STT -> IzvajalnikF3.stt state operand
  | STX -> IzvajalnikF3.stx state operand

  (* Control / IO *)
  | TIX -> IzvajalnikF3.tix state operand
  |_ -> failwith ("Mnemonic" ^  (OpcodeTable.string_of_mnemonic mnemonic) ^ "falsely flaged as format 3")


let executeFormat4 (state : Processor.state) (nixbpe : nixbpe) (mnemonic: OpcodeTable.mnemonic): unit = 
  let address = getAddress state in
  Processor.pcIncrement state 3;
  match mnemonic with
  (*aritmetika*)
  | ADD -> notImplemented "ADD4"
  | ADDF -> notImplemented "ADDF4"
  | AND -> notImplemented "AND4"
  | COMP -> notImplemented "COMP4"
  | COMPF -> notImplemented "COMPF4"
  | DIV -> notImplemented "DIV4"
  | MUL -> notImplemented "MUL4"
  | OR -> notImplemented "OR4"
  | SUB -> notImplemented "SUB4"
  | SUBF -> notImplemented "SUBF4"
  | TD -> notImplemented "TD4"
  | WD -> notImplemented "WD4"

  (* Jump / subroutine *)
  | J -> notImplemented "J4"
  | JEQ -> notImplemented "JEQ4"
  | JGT -> notImplemented "JGT4"
  | JLT -> notImplemented "JLT4"
  | JSUB -> notImplemented "JSUB4"
  | RSUB -> notImplemented "RSUB4"

  (* Load/store *)
  | LDA -> notImplemented "LDA4"
  | LDB -> notImplemented "LDB4"
  | LDCH -> notImplemented "LDCH4"
  | LDF -> notImplemented "LDF4"
  | LDL -> notImplemented "LDL4"
  | LDS -> notImplemented "LDS4"
  | LDT -> notImplemented "LDT4"
  | LDX -> notImplemented "LDX4"
  | LPS -> notImplemented "LPS4"
  | STA -> notImplemented "STA4"
  | STB -> notImplemented "STB4"
  | STCH -> notImplemented "STCH4"
  | STF -> notImplemented "STF4"
  | STL -> notImplemented "STL4"
  | STS -> notImplemented "STS4"
  | STSW -> notImplemented "STSW4"
  | STT -> notImplemented "STT4"
  | STX -> notImplemented "STX4"

  (* Control / IO *)
  | TIX -> notImplemented "TIX4"
  |_ -> failwith ("Mnemonic" ^  (OpcodeTable.string_of_mnemonic mnemonic) ^ "falsely flaged as format 4")



(*execute format 3_4*)
let executeFormat3_4 (state : Processor.state) (mnemonic : OpcodeTable.mnemonic) : unit = 
  let nixbpe = getNIXBPE state in 
  match nixbpe.e with
  | 0 -> executeFormat3 state nixbpe mnemonic
  | 1 -> executeFormat4 state nixbpe mnemonic
  | _ -> failwith "invalid computation of nxbpe"


(*execute ukaza*)
let execute (state : Processor.state) : unit =
  let byte1 = Processor.readMem state 0 in (*read the 1st byte of the instruction*)
  try
    let {OpcodeTable.mnemonic; OpcodeTable.format}  = Decoder.decoder byte1 in (*determen the format of the instruction from the 1st byte*)
    match format with
    | F1 -> executeFormat1 state mnemonic
    | F2 -> executeFormat2 state mnemonic
    | F3_4 -> executeFormat3_4 state mnemonic
  with
    | Failure msg -> byte1 |> Char.code |> invalidOpcode