/******************************************
 * FileName.cpp
 *
 * Your Name Here
 * Today's Date
 * CS2308-00X - Project #1.0
 *
 * Briefly describe what the code does.
 *
 * puzzle1: FIXME: What is the image in solution1?
 * puzzle2: FIXME: What is the image in solution2?
 * puzzle3: FIXME: What is the image in solution3?
 * ****************************************/
#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

/* User-defined Structure to hold the RGB values of an individual pixel */
struct Pixel {
  int red;
  int green;
  int blue;
};

/* User-defined Constants */
/* This is the only allowed use of global variables */
const int NROWS = 300;  // Image # of rows
const int NCOLS = 400;  // Image # of columns
const int MAXVAL = 255; // Maximum pixel RGB value

/* Function Prototypes */
void recoverImage1(Pixel [][NCOLS]);
void recoverImage2(Pixel [][NCOLS]);
void recoverImage3(Pixel [][NCOLS]);
void readPPM(ifstream &, Pixel [][NCOLS]);
void writePPM(ofstream &, Pixel [][NCOLS]);

// ============================================================================
// main: Creates a 2-d array of pixels to hold each image, then iteratively
//       reads in each image, calls the image's recoverImage() function, and
//       writes the solution image to disk.
// returns 0 for success
// ============================================================================
int main() {
  Pixel image[NROWS][NCOLS];
  ifstream fIn;
  ofstream fOut;

  cout << "Processing puzzle1...";

  // Open puzze1.ppm and read pixel data into 2D array 'image'
  // Call recoverImage1() function to un-distort pixels
  // Write solution image to file as solution1.ppm
  fIn.open("puzzle1.ppm");
  if(!fIn) {
    cout << "Error opening puzzle1.ppm\n" << endl;
    exit(-1);
  }
  readPPM(fIn, image);
  fIn.close();
  fIn.clear();
  recoverImage1(image);
  fOut.open("solution1.ppm");
  writePPM(fOut, image);
  fOut.close();
  fOut.clear();

  cout << "done" << endl;
  cout << "Processing puzzle2...";

  // Open puzze2.ppm and read pixel data into 2D array 'image'
  // Call recoverImage2() function to un-distort pixels
  // Write solution image to file as solution2.ppm
  fIn.open("puzzle2.ppm");
  if(!fIn) {
    cout << "Error opening puzzle2.ppm\n" << endl;
    exit(-1);
  }
  readPPM(fIn, image);
  fIn.close();
  fIn.clear();
  recoverImage2(image);
  fOut.open("solution2.ppm");
  writePPM(fOut, image);
  fOut.close();
  fOut.clear();

  cout << "done" << endl;
  cout << "Processing puzzle3...";

  // Open puzze3.ppm and read pixel data into 2D array 'image'
  // Call recoverImage3() function to un-distort pixels
  // Write solution image to file as solution3.ppm
  fIn.open("puzzle3.ppm");
  if(!fIn) {
    cout << "Error opening puzzle3.ppm\n" << endl;
    exit(-1);
  }
  readPPM(fIn, image);
  fIn.close();
  fIn.clear();
  recoverImage3(image);
  fOut.open("solution3.ppm");
  writePPM(fOut, image);
  fOut.close();
  fOut.clear();

  cout << "done" << endl;
  return 0;
}

// ============================================================================
// recoverImage1: FIXME
// ============================================================================
void recoverImage1(Pixel image[][NCOLS]) {
  // TODO: FIXME: Your code goes here
    for(int r = 0; r < NROWS; r++) {
        for(int c = 0; c < NCOLS; c++) {
            image[r][c].red*=10;
        }
    }
}

// ============================================================================
// recoverImage2: FIXME
// ============================================================================
void recoverImage2(Pixel image[][NCOLS]) {
  // TODO: FIXME: Your code goes here
  for(int r = 0; r < NROWS; r++) {
        for(int c = 0; c < NCOLS; c++) {
            image[r][c].blue*=20;
            image[r][c].green*=20;
        }
    }
}

// ============================================================================
// recoverImage3: FIXME
// ============================================================================
void recoverImage3(Pixel image[][NCOLS]) {
  // TODO: FIXME: Your code goes here
    for(int r = 0; r < NROWS; r++) {
        for(int c = 0; c < NCOLS; c++) {
            if(image[r][c].blue<16){
                image[r][c].blue*=16;
            }
            else
                image[r][c].blue=0;

        }
    }
}

// ============================================================================
// readPPM: from a file input stream, reads the header info and pixel table
//          of a PPM image and stores it in the 2-d Pixel array given as an
//          argument.
// fIn: a reference to a file input stream of the input image, which must be
//      a 300x400 PPM format image with a max pixel value of 255
// image: a 2-d array of Pixels with width NCOLS, to populate with the image
//        data
// ============================================================================
void readPPM(ifstream &fIn, Pixel image[][NCOLS]) {
  string temp;
  int cols, rows, max;
  // Make sure this is actually a PPM file
  fIn >> temp;
  if(temp != "P3") {
    cout << "Invalid PPM file format specifier: must be P3\n";
    exit(-1);
  }
  // Read in row and column count
  // This code is only intended to support 300x400 images
  fIn >> cols;
  fIn >> rows;
  if(cols != NCOLS) {
    cout << "Invalid image width: must be " << NCOLS << " columns\n";
    exit(-1);
  }
  if(rows != NROWS) {
    cout << "Invalid image height: must be " << NROWS << " rows\n";
    exit(-1);
  }
  // Read in maximum pixel value
  // This code is only intended to support images that use 0-255 for
  // pixel values
  fIn >> max;
  if(max != MAXVAL) {
    cout << "Invalid image pixel max value: must be " << MAXVAL << endl;
    exit(-1);
  }

  // Read pixel table into argument array
  for(int r = 0; r < NROWS; r++) {
    for(int c = 0; c < NCOLS; c++) {
      fIn >> image[r][c].red;
      fIn >> image[r][c].green;
      fIn >> image[r][c].blue;
    }
  }
}

// ============================================================================
// writePPM: writes a PPM image to the file output stream given as an argument,
//           using NROWS and NCOLS as the height and width, MAXVAL as the max
//           pixel value, and the 2-d Pixel array passed as an argument as the
//           pixel values.
// fOut: a reference to the file output stream where the output image is to be
//       written
// image: a 2-d array of Pixels with width NCOLS, holding the pixel values to
//        be written as a PPM image
// ============================================================================
void writePPM(ofstream &fOut, Pixel image[][NCOLS]) {
  // Output header information
  fOut << "P3" << endl;
  fOut << NCOLS << " " << NROWS << endl;
  fOut << MAXVAL << endl;
  // Output pixel table
  for(int r = 0; r < NROWS; r++) {
    for(int c = 0; c < NCOLS; c++) {
      fOut << image[r][c].red << endl;
      fOut << image[r][c].green << endl;
      fOut << image[r][c].blue << endl;
    }
  }
}