SudokuModel_D

package csc143.sudoku;

import javax.swing.*;
import csc143.sudoku.*;
import java.awt.*;
import java.util.*;

/**
 * @author Vita Wiebe
 * @version PAx: Sudoku Serialization and Make-Up
 * A class extending SudokuCore, which in turn extends
 * SudokuBase.
 */
public class SudokuModel extends SudokuCore {

    /** Our class constructor.
     * @param int r, int c
     */
    public SudokuModel(int r, int c) {
        super(r, c);
        int size = super.getSize();
    }

    /**
     * Need to go thru cellCoordinates[][] Row index # n and determine
     * whether Row is complete, incomplete, or contains duplicates (error).
     * @param int n, the Row on the Board we wish to check
     * @return enum State, the state of the Row in question.
     */
    public State getRowState(int n) {

        // Columns are total number for this whole game board
        // (which is why they're squared).
        int columns = getColumns() * getColumns();
        int size = getSize() * getSize();
        int gridSorted[] = new int[columns];

        // Initialize all values in array to -1;
        // this will flag the end of values in array.
        // for(int item : gridSorted) {
//             gridSorted[item] = -1;
//         }

        // Put the germane range of values from super.grid[] into
        // gridSorted[] (depending on row we're examining).
        //for(int i = 0; i < columns; i++) {
            int i = 0;
            for(int col = 0; col < columns; col++) {

                gridSorted[i] = super.getValue(n, col);
                i++;
            }
        }

        // Sort the values from grid/gridSorted associated
        // with row # n of cellCoordinates[][].
        Arrays.sort(gridSorted);

        // hasEmpty is a flag to store when an empty
        // element has been found.
        boolean hasEmpty = false;
        if(gridSorted[0] == 0) {
            hasEmpty = true;
        }

        // Iterate thru gridSorted, looking for empties
        // and duplicate values.
        for(int j = 1; j < columns; j++) {
            if((gridSorted[j] == gridSorted[j - 1]) &&
               (gridSorted[j] != 0)) {
                  return State.ERROR;
            } else if(gridSorted[j] == 0) {
                hasEmpty = true;
            }
        }
        if(hasEmpty) {
            return State.INCOMPLETE;
        }
        return State.COMPLETE;
    }

   /**
    * Need to go thru cellCoordinates[][] Column index # n and determine
    * whether Column is complete, incomplete, or contains duplicates (error).
    * @param int n, the Column on the Board we wish to check
    * @return enum State, the state of the Column in question.
    */
   public State getColumnState(int n) {

        // Rows is the total number of rows on the board
        int rows = getRows() * getRows();
        int size = getSize()* getSize();

        // Create a copy of grid[], our superclass's array for holdinig
        // the values of each cell on the board.
        int gridSorted[] = new int[size];

        // Put the germane range of values from super.grid[] into
        // gridSorted[] (depending on column we're examining).
        for(int i = 0; i < size; i++) {

            for(int row = 0; row < rows; row++) {

                gridSorted[i] = super.getValue(row, n);
            }
        }

        // Sort the values from grid/gridSorted associated
        // with column # n of cellCoordinates[][].
        Arrays.sort(gridSorted);

        // hasEmpty is a flag to store when an empty
        // element has been found.
        boolean hasEmpty = false;
        if(gridSorted[0] == 0) {
            hasEmpty = true;
        }

        // Iterate thru gridSorted, looking for empties
        // and duplicate values.
        for(int j = 1; j < gridSorted.length; j++) {
            if(gridSorted[j] == gridSorted[j - 1]) {
                return State.ERROR;
            } else if(gridSorted[j] == 0) {
                hasEmpty = true;
            }
        }
        if(hasEmpty) {
            return State.INCOMPLETE;
        }
        return State.COMPLETE;
    }

    // Search the given Region and return INCOMPLETE if empties and no
    // duplicate values, ERROR if duplicates, and COMPLETE otherwise.
    public State getRegionState(int n) {

        return State.COMPLETE;
    }

}