import betaflight_wizard/msp/msp
import gleam/bit_array
import gleam/int

pub fn msp_encode_v1_empty_test() {
  do_msp_encode_v1_empty(0)
}

pub fn encode_random_v1_message_test() {
  let op_code = int.random(256)
  let input_data_length = 100 + int.random(100)
  let input_data = fill_input_data(input_data_length, 0, <<>>)

  let encoded = msp.encode_v1_raw(op_code, input_data)
  let encoded_length = bit_array.byte_size(encoded)

  assert bit_array.slice(encoded, 0, 3) == Ok(<<"$M":utf8, "<":utf8>>)
  assert bit_array.slice(encoded, 3, 1) == Ok(<<input_data_length:size(8)>>)
  assert bit_array.slice(encoded, 4, 1) == Ok(<<op_code:size(8)>>)
  assert bit_array.slice(encoded, 5, input_data_length) == Ok(input_data)
  assert bit_array.slice(encoded, encoded_length - 1, 1)
    == Ok(<<
      msp.calculate_crc_v1(input_data_length, op_code, input_data, 0):size(8),
    >>)
}

pub fn msp_encode_v2_empty_test() {
  do_msp_encode_v2_empty(0)
}

pub fn encode_random_v2_message_test() {
  let op_code = int.random(65_536)
  let flag = int.random(256)
  let input_data_length = int.random(65_536)
  let input_data = fill_input_data(input_data_length, 0, <<>>)

  let encoded = msp.encode_v2_raw(command: op_code, flag:, data: input_data)
  let encoded_length = bit_array.byte_size(encoded)

  // preamble, direction, flag, cmd low, cmd high, size, data, crc
  // preamble, direction
  assert bit_array.slice(encoded, 0, 3) == Ok(<<"$X", "<">>)
  // flag
  assert bit_array.slice(encoded, 3, 1) == Ok(<<flag>>)
  // cmd
  assert bit_array.slice(encoded, 4, 2) == Ok(<<op_code:little-size(16)>>)
  // size
  assert bit_array.slice(encoded, 6, 2)
    == Ok(<<input_data_length:little-size(16)>>)
  // data 
  assert bit_array.slice(encoded, 8, input_data_length) == Ok(input_data)
  // crc
  assert bit_array.slice(encoded, encoded_length - 1, 1)
    == Ok(<<
      msp.calculate_crc_v2(
        size: input_data_length,
        flag:,
        cmd: op_code,
        data: input_data,
      ),
    >>)
}

fn do_msp_encode_v1_empty(cmd: Int) {
  case cmd {
    256 -> Nil
    _ -> {
      let encoded = msp.encode_v1_raw(cmd, <<>>)
      // preamble, direction, data size, command, data, crc
      assert encoded == <<"$M", "<", 0, cmd, cmd>>
      do_msp_encode_v1_empty(cmd + 1)
    }
  }
}

fn fill_input_data(input_data_length: Int, n: Int, data: BitArray) -> BitArray {
  case n {
    n if n >= input_data_length -> data
    n ->
      fill_input_data(input_data_length, n + 1, <<data:bits, int.random(256)>>)
  }
}

fn do_msp_encode_v2_empty(cmd: Int) {
  case cmd {
    // MSPv2 commands are 16bit rather than 8bit
    65_536 -> Nil
    _ -> {
      let encoded = msp.encode_v2_raw(command: cmd, flag: 0, data: <<>>)
      // preamble, direction, flag, cmd low, cmd high, size, data, crc
      assert encoded
        == <<
          "$X",
          "<",
          0,
          cmd:little-size(16),
          0:size(16),
          // skip data
          msp.calculate_crc_v2(size: 0, cmd: cmd, flag: 0, data: <<>>),
        >>
      do_msp_encode_v2_empty(cmd + 1)
    }
  }
}