#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

#define UNASSIGNED 0
#define N 9

using namespace std;

bool FindUnassignedLocation(int grid[N][N], int &row, int &col);
bool isSafe(int grid[N][N], int row, int col, int num);
bool SolveSudoku(int grid[N][N]);
void printGrid(int grid[N][N]);

void generateSudoku(int grid[N][N]) {
    // Clear the grid
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            grid[i][j] = UNASSIGNED;

    // Fill the diagonal 3x3 matrices
    for (int i = 0; i < N; i += 3) {
        vector<int> numList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        for (int row = i; row < i + 3; row++) {
            for (int col = i; col < i + 3; col++) {
                int num = numList.back();
                numList.pop_back();
                grid[row][col] = num;
            }
        }
    }

    // Solve the partially filled grid
    SolveSudoku(grid);

    // Remove random elements to create the puzzle
    int numToRemove = 40; // You can adjust this for difficulty
    while (numToRemove > 0) {
        int cellId = rand() % (N * N);
        int row = cellId / N;
        int col = cellId % N;
        if (grid[row][col] != UNASSIGNED) {
            grid[row][col] = UNASSIGNED;
            numToRemove--;
        }
    }
}

void printGridWithLines(int grid[N][N]) {
    for (int row = 0; row < N; row++) {
        if (row % 3 == 0) cout << "+-------+-------+-------+" << endl;
        for (int col = 0; col < N; col++) {
            if (col % 3 == 0) cout << "| ";
            if (grid[row][col] == UNASSIGNED)
                cout << ". ";
            else
                cout << grid[row][col] << " ";
        }
        cout << "|" << endl;
    }
    cout << "+-------+-------+-------+" << endl;
}

bool SolveSudoku(int grid[N][N]) {
    int row, col;

    if (!FindUnassignedLocation(grid, row, col))
        return true;

    for (int num = 1; num <= 9; num++) {
        if (isSafe(grid, row, col, num)) {
            grid[row][col] = num;

            if (SolveSudoku(grid))
                return true;

            grid[row][col] = UNASSIGNED;
        }
    }
    return false;
}

bool FindUnassignedLocation(int grid[N][N], int &row, int &col) {
    for (row = 0; row < N; row++)
        for (col = 0; col < N; col++)
            if (grid[row][col] == UNASSIGNED)
                return true;
    return false;
}

bool UsedInRow(int grid[N][N], int row, int num) {
    for (int col = 0; col < N; col++)
        if (grid[row][col] == num)
            return true;
    return false;
}

bool UsedInCol(int grid[N][N], int col, int num) {
    for (int row = 0; row < N; row++)
        if (grid[row][col] == num)
            return true;
    return false;
}

bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num) {
    for (int row = 0; row < 3; row++)
        for (int col = 0; col < 3; col++)
            if (grid[row + boxStartRow][col + boxStartCol] == num)
                return true;
    return false;
}

bool isSafe(int grid[N][N], int row, int col, int num) {
    return !UsedInRow(grid, row, num) &&
           !UsedInCol(grid, col, num) &&
           !UsedInBox(grid, row - row % 3, col - col % 3, num) &&
           grid[row][col] == UNASSIGNED;
}

bool isFull(int grid[N][N]) {
    for (int row = 0; row < N; row++)
        for (int col = 0; col < N; col++)
            if (grid[row][col] == UNASSIGNED)
                return false;
    return true;
}

bool isValid(int grid[N][N]) {
    for (int row = 0; row < N; row++) {
        for (int col = 0; col < N; col++) {
            if (grid[row][col] != UNASSIGNED) {
                int num = grid[row][col];
                grid[row][col] = UNASSIGNED;
                if (!isSafe(grid, row, col, num)) {
                    grid[row][col] = num;
                    return false;
                }
                grid[row][col] = num;
            }
        }
    }
    return true;
}

int main() {
    srand(time(0));
    int grid[N][N];
    int original[N][N];
    generateSudoku(grid);
    
    // Copy original grid
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            original[i][j] = grid[i][j];

    printGridWithLines(grid);

    while (!isFull(grid) || !isValid(grid)) {
        int x, y, num;
        cout << "Enter row, column and number (x y num): ";
        cin >> x >> y >> num;
        x--; y--; // adjust for 0-based index

        if (original[x][y] != UNASSIGNED) {
            cout << "Cannot change the original puzzle numbers!" << endl;
        } else if (num != UNASSIGNED && !isSafe(grid, x, y, num)) {
            cout << "Number conflicts with existing entries!" << endl;
        } else {
            grid[x][y] = num;
            printGridWithLines(grid);
        }

        if (isFull(grid) && isValid(grid)) {
            cout << "Congratulations! You've solved the Sudoku!" << endl;
            break;
        }
    }

    return 0;
}