// GridMaker.java
// A solution to CS 10 assignment 3, part 2, Fall 2008
// cmc, 10/21/08

import java.awt.Color;
import java.util.Scanner;

public class GridMaker {

    private enum Command { NEW, SET, BRIGHTEN, DARKEN, SETarea,
                           BRIGHTENarea, DARKENarea, DISPLAY, QUIT }

    private final static int MIN = 2, MAX = 400; 

    public static void main(String[] args) {

        ColorGrid grid = new ColorGrid(); // default is 100x100, all white

        System.out.println("Accepting these commands:");
        for (Command c : Command.values())
            System.out.println("  " + c);

        Scanner input = new Scanner(System.in);

        while (input.hasNextLine()) {
            String line = input.nextLine();
            Scanner parser = new Scanner(line);

            if (!parser.hasNext()) // means it's just a blank line
                continue;

            String firstToken = parser.next();
            Command command = getCommand(firstToken);
            if (command == null) {
                printError("bad command", line);
                continue;
            }

            switch(command) {

                case NEW:
                    grid = newGrid(parser, grid);
                    break;

                case SET:
                    set(parser, grid);
                    break;

                case BRIGHTEN:
                    brighten(parser, grid);
                    break;

                case DARKEN:
                    darken(parser, grid);
                    break;

                case SETarea:
                    setArea(parser, grid);
                    break;

                case BRIGHTENarea:
                    brightenArea(parser, grid);
                    break;

                case DARKENarea:
                    darkenArea(parser, grid);
                    break;

                case DISPLAY:
                    CS10Display.showGrid(grid.grid());
                    break;

                case QUIT:
                    return;

            }
        }
    }

    // helper translates the String into one of the commands or null
    private static Command getCommand(String s) {
        s = s.toUpperCase(); // reuses parameter; does not change passed value

        for (Command c : Command.values())
            if (s.equals(c.toString().toUpperCase()))
                return c;

        return null; // not one of the valid commands
    }

    // helper prints an error message
    private static void printError(String message) {
        System.out.println("ERROR: " + message);
    }

    // helper prints an error message with an errant input string
    private static void printError(String message, String echo) {
        printError(String.format("%s: \"%s\"", message, echo));
    }

    // helper prints an error message with an errant input value
    private static void printError(String message, int value) {
        printError(message, String.valueOf(value));
    }

    // helper gets an int in the range min to max
    // prints message and returns min-1 if input error
    private static int get(String what, Scanner from, int min, int max) {
        int result = min - 1;

        if (!from.hasNext())
            printError("missing " + what);

        else if (!from.hasNextInt())
            printError("bad " + what, from.next());

        else {
            int input = from.nextInt();
            if (input >= min && input <= max)
                result = input;
            else
                printError(what + " out of range", input);
        }

        return result;
    }

    // helper gets color values from user or returns null if user error
    private static Color getColor(Scanner s) {
        final int minVal = 0, maxVal = 255;

        int red = get("red value", s, minVal, maxVal);
        if (red < minVal)
            return null;   // because get() returns min-1 if user error

        int green = get("green value", s, minVal, maxVal);
        if (green < minVal)
            return null;

        int blue = get("blue value", s, minVal, maxVal);
        if (blue < minVal)
            return null;

        return new Color(red, green, blue);
    }

// Actual solution starts here

    // handles NEW case
    private static ColorGrid newGrid(Scanner s, ColorGrid existing) {
        if (!s.hasNext())
            return new ColorGrid(); // default grid

        int rows = get("new row size", s, MIN, MAX);
        if (rows < MIN)
            return existing;

        int columns = get("new column size", s, MIN, MAX);
        if (columns < MIN)
            return existing;

        if (!s.hasNext())
            return new ColorGrid(rows, columns); // default color

        Color initialColor = getColor(s);
        if (initialColor != null)
            return new ColorGrid(rows, columns, initialColor);
        else
            return existing;
    }

    // handles SET case
    private static void set(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row = get("row to set", s, 0, maxRow);
        if (row < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column = get("column to set", s, 0, maxColumn);
        if (column < 0)
            return;

        Color color = getColor(s);
        if (color != null)
            grid.set(row, column, color);
    }

    // handles BRIGHTEN case
    private static void brighten(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row = get("row to brighten", s, 0, maxRow);
        if (row < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column = get("column to brighten", s, 0, maxColumn);
        if (column < 0)
            return;

        grid.brighten(row, column);
    }

    // handles DARKEN case
    private static void darken(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row = get("row to darken", s, 0, maxRow);
        if (row < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column = get("column to darken", s, 0, maxColumn);
        if (column < 0)
            return;

        grid.darken(row, column);
    }


    // handles SETarea case
    private static void setArea(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row1 = get("first row to set", s, 0, maxRow);
        if (row1 < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column1 = get("first column to set", s, 0, maxColumn);
        if (column1 < 0)
            return;

        int row2 = get("second row to set", s, row1, maxRow);
        if (row2 < row1)
            return;

        int column2 = get("second column to set", s, column1, maxColumn);
        if (column2 < column1)
            return;

        Color color = getColor(s);
        if (color != null)
            grid.set(row1, column1, row2, column2, color);
    }

    // handles BRIGHTENarea case
    private static void brightenArea(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row1 = get("first row to brighten", s, 0, maxRow);
        if (row1 < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column1 = get("first column to brighten", s, 0, maxColumn);
        if (column1 < 0)
            return;

        int row2 = get("second row to brighten", s, row1, maxRow);
        if (row2 < row1)
            return;

        int column2 = get("second column to brighten", s, column1, maxColumn);
        if (column2 < column1)
            return;

        grid.brighten(row1, column1, row2, column2);
    }

    // handles DARKENarea case
    private static void darkenArea(Scanner s, ColorGrid grid) {
        int maxRow = grid.rows() - 1;
        int row1 = get("first row to darken", s, 0, maxRow);
        if (row1 < 0)
            return;

        int maxColumn = grid.columns() - 1;
        int column1 = get("first column to darken", s, 0, maxColumn);
        if (column1 < 0)
            return;

        int row2 = get("second row to darken", s, row1, maxRow);
        if (row2 < row1)
            return;

        int column2 = get("second column to darken", s, column1, maxColumn);
        if (column2 < column1)
            return;

        grid.darken(row1, column1, row2, column2);
    }
}