with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Command_Line; use Ada.Command_line;

-- Note: Requirements:
-- Needs to read board file from command line, quitting if it doesn't exist
    -- And must display a proper error message for this.
-- Needs to ignore all lines and rows other than the first 9
-- Must attempt to find a solution, and throw a message if no solution exists

procedure Assignment1 is

    -- Stores a 3x3 corner of a Sudoku Board
    subtype Wedge_Range is integer range 1..3;
    type Sudoku_Wedge is array (Wedge_Range, Wedge_Range) of character;
    -- Stores a full Sudoku Board
    subtype Sudoku_Range is integer range 1..9;
    type Sudoku_Board is array (Sudoku_Range, Sudoku_Range) of character;

    Original_Board : Sudoku_Board;
    Test_Board : Sudoku_Board;

    Arguments_Are_Sane : Boolean;
    File_Is_Sane : Boolean;

    -- Prints out the Sudoku Board
    procedure Print_Board(Board : in Sudoku_Board) is
    begin
        for Y in 1..9 loop
            for X in 1..9 loop
                Put(Board(X, Y));
            end loop;
            new_line;
        end loop;
    end Print_Board;

    -- Linear search to check if the buffer contains the
    -- Given character
    function Contains_Char(Sting : in String;
        Char : in Character) return boolean is
    begin
        for A in 1..Sting'Length loop
            if Sting(A) = Char then
                return true;
            end if;
        end loop;
        return false;
    end Contains_Char;

    -- Checks a single 3x3 wedge to see if it is legal.s
    function Check_Wedge(Test : in Sudoku_Wedge) return boolean is
        buffer : String(1..9);
        counter : Integer;
    begin
        buffer := "000000000";
        Counter := 1;
        for Y in 1..3 loop
            for X in 1..3 loop
                if Contains_Char(buffer, Test(X,Y)) then
                    return false;
                else
                    buffer(counter) := Test(X,Y);
                    counter := counter + 1;
                end if;
            end loop;
        end loop;
        return true;
    end Check_Wedge;

    -- Tests the board if it is legal.
    function Check_Board(Test : in Sudoku_Board) return boolean is
        buffer : String(1..9);
        Wedge_Counter_X : Integer;
        Wedge_Counter_Y : Integer;
    begin
        buffer := "000000000";
        -- Check if duplicate # in row
        for X in 1..9 loop -- For each Row
            for Y in 1..9 loop -- For each column
                if Test(X,Y) /= '.' then
                    if Contains_Char(buffer, Test(X,Y)) then
                        return false;
                    else
                        buffer(Y) := Test(X,Y);
                    end if;
                else
                    return false;
                end if;
            end loop;
            buffer := "000000000";
        end loop;
        -- Check if duplicate # in column
        for Y in 1..9 loop
            for X in 1..9 loop
                if Test(X,Y) /= '.' then
                    if Contains_Char(buffer, Test(X,Y)) then
                        return false;
                    else
                        buffer(X) := Test(X,Y);
                    end if;
                else
                    return false;
                end if;
            end loop;
            buffer := "000000000";
        end loop;
        -- Check if duplicate # in 3x3 wedge
        Wedge_Counter_X := 1;
        Wedge_Counter_Y := 1;
        for X in 1..3 loop
            for Y in 1..3 loop
                if (Check_Wedge(Test(
                    Wedge_Counter_X..(X * 3),
                    Wedge_Conuter_Y..(Y * 3)
                )) = false) then
                    return false;
                else
                    Wedge_Counter_Y := Wedge_Counter_Y + 3;
                end if;
            end loop;
            Wedge_Counter_Y := 1;
            Wedge_Counter_X := Wedge_Counter_X + 3;
        end loop;
        -- No other problems, return true
        return true;
    end Check_Board;

    -- Self explanatory, handles command line arguments
    function Handle_Arguments return boolean is
    begin
        if Argument_Count = 0 then
            return false;
        else
            return true;
        end if;

    end Handle_Arguments;

    -- Reads initial text file and uses it to fill Original_Board
    function Read_Board_File(Name : in String) return boolean is
        Board_File : File_Type;
    begin
        -- Open input file and check for sanity
        begin
            Open(Board_File, Mode => In_File, Name => Name);
        exception
            when Name_Error | Use_Error =>
                put("File either does not exist or cannot be read");
                new_line;
                return false; -- false for file can't be opened
        end;
        -- Write to Sudoku Board
        for y in 1..9 loop
            for x in 1..9 loop
                get(Board_File, Original_Board(X, Y));
            end loop;
            if not End_Of_Line(Board_File) then
                Skip_Line(Board_File);
            end if;
        end loop;
        Close(Board_File);
        return true;
    end Read_Board_File;

    -- Main Recursive backtrack function for solving sudoku.
    procedure Recursive_Solver is
        -- Note: This may be changed from a procedure to a function
        -- And it needs to have some sort of input argument
        -- This is just a prototype.
    begin
        null;
    end Recursive_Solver;

begin
    -- First check to see if the program can be run
    Arguments_Are_Sane := Handle_Arguments;
    -- Logically, if there is no command line argument
    -- Then we cannot read any file.
    if Arguments_Are_Sane then
        File_Is_Sane := Read_Board_File(Argument(1));
    else
        File_Is_Sane := false;
    end if;

    if File_Is_Sane then
        Print_Board(Original_Board); -- Do work here
        if Check_Board(Original_Board) then
            Put("Board works"); new_line;
        else
            Put("Board does not work"); new_line;
        end if;
    else
        Put("Error");-- Make program exit with error here
        new_line;
    end if;
end Assignment1;