#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define SIZE 9
#define EMPTY 0
#define LEVEL_NUMBER 3


int difficulty;
int selected_level;


void Game_loop(); //is instead of main
void Level_Pool(int difficulty);
void selectLevel(int grid[SIZE][SIZE]);
void initializeGrid(int grid[SIZE][SIZE]);
void create_playing_field(int grid[SIZE][SIZE], int difficulty, int level);
void Player_actions_for_playing(int grid[SIZE][SIZE]);
void giving_hints_to_player(int grid[SIZE][SIZE]);
void write_userinput_into_Sudoku(int grid[SIZE][SIZE]);
void printGrid(int grid[SIZE][SIZE]);
void check_if_Sudoku_solved(int grid[SIZE][SIZE]);



int availableLevels[3][3][SIZE][SIZE] = {
    { //easy
    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 2}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}}},

    {//medium
     {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}}
    },

    {//hard
    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}},

    {{0, 0, 3, 0, 2, 1, 8, 0, 0},
     {6, 0, 0, 0, 7, 0, 1, 3, 2},
     {9, 2, 1, 5, 0, 0, 7, 6, 4},
     {7, 6, 0, 3, 0, 0, 4, 0, 0},
     {8, 5, 4, 1, 9, 7, 0, 0, 0},
     {1, 0, 0, 4, 0, 6, 0, 0, 0},
     {2, 9, 0, 8, 1, 5, 0, 0, 6},
     {0, 4, 8, 2, 0, 9, 5, 0, 0},
     {5, 0, 0, 7, 0, 3, 2, 0, 0}}
    }
};

int solutionLevels[3][3][SIZE][SIZE] = {
    
    { //easy
    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}}},

    {//medium
     {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}}
    },

    {//hard
    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}},

    {{4, 7, 3, 6, 2, 1, 8, 5, 9},
     {6, 8, 5, 9, 7, 4, 1, 3, 2},
     {9, 2, 1, 5, 3, 8, 7, 6, 4},
     {7, 6, 9, 3, 5, 2, 4, 8, 1},
     {8, 5, 4, 1, 9, 7, 6, 2, 3},
     {1, 3, 2, 4, 8, 6, 9, 7, 5},
     {2, 9, 7, 8, 1, 5, 3, 4, 6},
     {3, 4, 8, 2, 6, 9, 5, 1, 7},
     {5, 1, 6, 7, 4, 3, 2, 9, 8}}
    }
};


void Game_loop() {
    int grid[SIZE][SIZE];
    selected_level = 0;

    while (1) {
        printf("\nDifficulty Function - Choose difficulty:\n");
        printf("1. Easy\n2. Medium\n3. Hard\n");
        printf("Enter the corresponding number or type 'quit' to exit: ");

        char input[10];
        scanf("%s", input);

        if (strcmp(input, "quit") == 0) {
            break;
        }

        difficulty = input[0] - '0'; // Convert the first character to an integer

        if ((difficulty >= 1 && difficulty <= 3) && input[1] == '\0') {
            Level_Pool(difficulty);
            selectLevel(grid);
            Player_actions_for_playing(grid);
        } else {
            printf("Invalid input. Please enter a number between 1 and 3.\n");
        }
        
    }
}

void Level_Pool(int difficulty) {
    printf("\nAvailable Levels for Difficulty %d:\n", difficulty);
    for (int i = 0; i < LEVEL_NUMBER; i++) {
        printf("%d. Level %d\n", i + 1, i + 1);
    }
}



void selectLevel(int grid[SIZE][SIZE]) {
    int level = 0;
    printf("\nSelect a level:\n");
    while (true){
    char level_select[10];
        scanf("%s", level_select);


        level = level_select[0] - '0'; // Convert the first character to an integer

        if ((level >= 1 && level <= 3) && level_select[1] == '\0') {
            selected_level = level;

            level--; // Adjust to 0-based index
            
            create_playing_field(grid, difficulty, selected_level);
            break;
        } else {
            printf("Invalid input. Please enter a number between 1 and 3.\n");
            
        }
    }
    
    
}

void initializeGrid(int grid[SIZE][SIZE]) {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            grid[i][j] = EMPTY;
        }
    }
}

void create_playing_field(int grid[SIZE][SIZE], int difficulty, int level) {
    initializeGrid(grid);
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            grid[i][j] = availableLevels[difficulty - 1][level - 1][i][j];
        }
    }
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            printf("%d", grid[i][j]);
        }
        printf("\n");
    }
   
    
}

void Player_actions_for_playing(int grid[SIZE][SIZE]) {
    while (1) {
        printf("\nTurn function - Choose an action:\n");
        printf("1. Hints\n");
        printf("2. Insert Number into Game\n");
        printf("3. Print Sudoku grid\n");
        printf("4. Check if your Solution is correct\n");
        printf("5. Select level\n");
        printf("6. Quit\n");

         int action;

        while (true){
            char action_str[10];
            scanf("%s", action_str);

            action = action_str[0] - '0'; // Convert the first character to an integer

            if ((action >= 1 && action <= 6) && action_str[1] == '\0') {
                break;
            } else {
                printf("Invalid input. Please enter a number between 1 and 6.\n");
            }
        }

        switch (action) {
            case 1:
                giving_hints_to_player(grid);
                break;
            case 2:
                write_userinput_into_Sudoku(grid);
                break;
            case 3:
                printGrid(grid);
                break;
            case 4:
                check_if_Sudoku_solved(grid);
                break;
            case 5:
                selectLevel(grid);
                break;
            case 6:
                printf("Exiting Sudoku program.\n");
                exit(0);
            default:
                printf("Invalid input. Please enter a number between 1 and 6.\n");
        }
    }
}



void giving_hints_to_player(int grid[SIZE][SIZE]) {
    printf("\nTip function - Choose an option:\n");
    printf("1. Set the user-specified cell to the right value\n");
    printf("2. Set the user-specified 3x3 field to the right values\n");
    printf("3. Solve the entire puzzle for the current level\n");
    
    
    int option = 0;

    while (true){
    char tip_str[10];
        scanf("%s", tip_str);


        option = tip_str[0] - '0'; // Convert the first character to an integer

        if ((option >= 1 && option <= 3) && tip_str[1] == '\0') {
            break;
        } else {
            printf("Invalid input. Please enter a number between 1 and 3.\n");
        }
    }

    switch (option) {
        case 1:
             printf("Enter the coordinates (row and column) separated by space:\n");
            int row, col;

            while (true){
            char row_str[10];
            char col_str[10];
            scanf("%s %s", row_str, col_str);


            row = row_str[0] - '0'; // Convert the first character to an integer
            col = col_str[0] - '0'; // Convert the first character to an integer

            if (((row >= 1 && row <= 9) && row_str[1] == '\0') && ((col >= 1 && col <= 9) && col_str[1] == '\0')) {
                break;
            } else {
                printf("Invalid input. Please enter a number between 1 and 9.\n");
            }
        }
            grid[row - 1][col - 1] = solutionLevels[difficulty - 1][selected_level - 1][row - 1][col - 1];
            printf("Value set successfully.\n");
            break;

        case 2:
            printf("Enter the coordinates (top-left cell of the 3x3 field) separated by space:\n");
            int startRow, startCol;

            while (true){
            char row_squ[10];
            char col_squ[10];
            scanf("%s %s", row_squ, col_squ);


            startRow = row_squ[0] - '0'; // Convert the first character to an integer
            startCol = col_squ[0] - '0'; // Convert the first character to an integer

            if (((startRow >= 1 && startRow <= 9) && row_squ[1] == '\0') && ((startCol >= 1 && startCol <= 9) && col_squ[1] == '\0')) {
                break;
            } else {
                printf("Invalid input. Please enter a number between 1 and 9.\n");
            }
        }
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    grid[startRow - 1 + i][startCol - 1 + j] =
                        solutionLevels[difficulty - 1][selected_level - 1][startRow - 1 + i][startCol - 1 + j];
                }
            }
            printf("3x3 field set successfully.\n");
            break;

        case 3:
            for (int i = 0; i < SIZE; i++) {
                for (int j = 0; j < SIZE; j++) {
                    grid[i][j] = solutionLevels[difficulty - 1][selected_level - 1][i][j];
                }
            }
            printf("Puzzle solved. \n");
            break;
        default:
            printf("Invalid option. Please enter a number between 1 and 3.\n");
    }
}

void write_userinput_into_Sudoku(int grid[SIZE][SIZE]) {
    printf("\nInput function - Choose an action:\n");
    printf("1. Insert value in an empty field\n");
    printf("2. Clear an already filled field\n");

    int action;

    while (true){
            char in_str[10];
            scanf("%s", in_str);

            action = in_str[0] - '0'; // Convert the first character to an integer

            if ((action >= 1 && action <= 2) && in_str[1] == '\0') {
                break;
            } else {
                printf("Invalid input. Please enter a number between 1 and 2.\n");
            }
        }

        switch (action) {
            case 1:
                printf("Enter the coordinates (row and column) separated by space:\n");
                int row_e, col_e, num;


                while (true){
                char rowe_str[10];
                char cole_str[10];
                scanf("%s %s", rowe_str, cole_str);

                row_e = rowe_str[0] - '0'; // Convert the first character to an integer
                col_e = cole_str[0] - '0'; // Convert the first character to an integer

                if (((row_e >= 1 && row_e <= 9) && rowe_str[1] == '\0') && ((col_e >= 1 && col_e <= 9) && cole_str[1] == '\0')) {
                    break;
                } else {
                    printf("Invalid input. Please enter a number between 1 and 9.\n");
                }
            }
                printf("Enter the value to insert (1-9):\n");


            

                while (true){
                char nume_str[10];
                scanf("%s", nume_str);

                num = nume_str[0] - '0'; // Convert the first character to an integer

                if ((num >= 1 && num <= 9) && nume_str[1] == '\0') {
                    grid[row_e - 1][col_e - 1] = num;
                    printf("Value inserted successfully.\n");
                    break;
                } else {
                    printf("Invalid input. Please enter a number between 1 and 9.\n");
                }
            }
                break;
            
            case 2:
                printf("Enter the coordinates (row and column) separated by space:\n");
                int row_d, col_d;


            while (true){
                char rowd_str[10];
                char cold_str[10];
                scanf("%s %s", rowd_str, cold_str);

                row_d = rowd_str[0] - '0'; // Convert the first character to an integer
                col_d = cold_str[0] - '0'; // Convert the first character to an integer

                if (((row_d >= 1 && row_d <= 9) && rowd_str[1] == '\0') && ((col_d >= 1 && col_d <= 9) && cold_str[1] == '\0')) {
                    grid[row_d - 1][col_d - 1] = 0;
                    printf("Cell cleared successfully.\n");
                    break;
                } else {
                    printf("Invalid input. Please enter a number between 1 and 9.\n");
                }
            }
                break;
            default:
                printf("Invalid input. Please enter 1 or 2.\n");
        }
        printGrid(grid);
}


void printGrid(int grid[SIZE][SIZE]) {
    printf("\nSudoku Grid:\n");
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            printf("%d ", grid[i][j]);
        }
        printf("\n");
    }
}

void check_if_Sudoku_solved(int grid[SIZE][SIZE]) {
    printf("\nDone function - Checking if the solution is correct...\n");

    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            if (grid[i][j] != solutionLevels[difficulty - 1][selected_level - 1][i][j]) {
                printf("Incorrect solution. Keep trying!\n");
                return;
            }
        }
    }

    printf("Congratulations! Sudoku is solved correctly.\n");
}


int main(){
    Game_loop();
    return 0;
}