(* This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this
   file, You can obtain one at https://mozilla.org/MPL/2.0/. *)

open Exapunks
open Common
open Helpers
open Re

let () = set_context __FILE__

let parse_code input =
  let parsed_code = Reader.parse_code input in
  if not (List.is_empty parsed_code.errors) then
    Error
      (parsed_code.errors
      |> List.map (fun (error : syntax_error) -> error.msg)
      |> String.concat ", ")
  else Ok parsed_code.ops

let parse_output input : (OpCode.t list, string) result = Ok input

let () =
  describe "#parse_code" (fun () ->
      specify "happy path" (fun () ->
          let code =
            {|
            NOOP
            NOTE notes work

            ; its own line
            ; COPY F X
            COPY F X ; at the end of a line
            ADDI X F X
            SUBI X F X
            MULI X F X
            DIVI X F X
            MODI X F X
            SWIZ X F X
            MARK LOOP
            JUMP LOOP
            TJMP LOOP
            FJMP LOOP
            TEST X = F
            TEST X < F
            TEST X > F
            REPL LOOP
            HALT
            LINK 800
            HOST X
            MODE
            VOID M
            TEST MRD
            MAKE
            GRAB 200
            GRAB X
            FILE T
            SEEK 2
            SEEK X
            VOID F
            DROP
            WIPE
            |}
          in
          let lines = parse_code code in
          let expected =
            Ok
              [
                NOOP;
                COPY (R F, X);
                ADDI (R X, R F, X);
                SUBI (R X, R F, X);
                MULI (R X, R F, X);
                DIVI (R X, R F, X);
                MODI (R X, R F, X);
                SWIZ (R X, R F, X);
                MARK "LOOP";
                JUMP "LOOP";
                TJMP "LOOP";
                FJMP "LOOP";
                TEST_EQ (R X, R F);
                TEST_LT (R X, R F);
                TEST_GT (R X, R F);
                REPL "LOOP";
                HALT;
                LINK (N 800);
                HOST X;
                MODE;
                VOID_M;
                TEST_MRD;
                MAKE;
                GRAB (N 200);
                GRAB (R X);
                FILE T;
                SEEK (N 2);
                SEEK (R X);
                VOID_F;
                DROP;
                WIPE;
              ]
          in
          Alcotest.check t_parse_result "" expected lines;

          ());

      specify "repeated registers in COPY" (fun () ->
          let lines = parse_code "COPY X X" in
          let expected = Error "CANNOT REPEAT REGISTERS" in
          Alcotest.check t_parse_result_re "" expected lines;
          ());
      ())