#include "helpers.h"
#include <math.h>

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    int total = 0;
    float avg = 0;

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            total = image[i][j].rgbtRed + image[i][j].rgbtGreen + image[i][j].rgbtBlue;
            avg = total / 3.00;
            image[i][j].rgbtRed = round(avg);
            image[i][j].rgbtGreen = round(avg);
            image[i][j].rgbtBlue = round(avg);
        }
    }
    return;
}

// Convert image to sepia
void sepia(int height, int width, RGBTRIPLE image[height][width])
{
    float sepia_red = 0;
    float sepia_green = 0;
    float sepia_blue = 0;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            sepia_red = (.393 * image[i][j].rgbtRed + .769 * image[i][j].rgbtGreen + .189 * image[i][j].rgbtBlue);
            sepia_green = (.349*image[i][j].rgbtRed) + (.686*image[i][j].rgbtGreen) + (.168*image[i][j].rgbtBlue);
            sepia_blue = (.272*image[i][j].rgbtRed) + (.534*image[i][j].rgbtGreen) + (.131*image[i][j].rgbtBlue);

            if (sepia_red > 255)
            {
                sepia_red = 255;
            }
            if (sepia_green > 255)
            {
                sepia_green = 255;
            }
            if (sepia_blue > 255)
            {
                sepia_blue = 255;
            }
            image[i][j].rgbtRed = round(sepia_red);
            image[i][j].rgbtGreen = round(sepia_green);
            image[i][j].rgbtBlue = round(sepia_blue);
        }
    }
    return;
}

// Reflect image horizontally
void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    int temp[3];
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width/2; j ++)
        {
            temp[0] = image[i][j].rgbtRed;
            temp[1] = image[i][j].rgbtGreen;
            temp[2] = image[i][j].rgbtBlue;

            image[i][j].rgbtRed = image[i][width - j - 1].rgbtRed;
            image[i][j].rgbtGreen = image[i][width - j - 1].rgbtGreen;
            image[i][j].rgbtBlue = image[i][width - j - 1].rgbtBlue;

            image[i][width - j - 1].rgbtRed = temp[0];
            image[i][width - j - 1].rgbtGreen = temp[1];
            image[i][width - j - 1].rgbtBlue = temp[2];
        }
    }
    return;
}

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    int xred = 0;
    int xgreen = 0;
    int xblue = 0;
    int yred = 0;
    int ygreen = 0;
    int yblue = 0;
    int totalred = 0;
    int totalgreen = 0;
    int totalblue = 0;
    int tempred = 0;
    int tempgreen = 0;
    int tempblue = 0;
    int pixels_used = 0;

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            for (int x = i - 1; x <= i + 1; x++)
            {
                if (x >= 0 && x <= height - 1)
                {
                    xred = image[i][j].rgbtRed;
                    xgreen = image[i][j].rgbtGreen;
                    xblue = image[i][j].rgbtBlue;
                    pixels_used++;
                }
            }
            for (int y = j - 1; y <= j + 1; y++)
            {
                if (y >= 0 && y < width - 1)
                {
                    yred = image[i][j].rgbtRed;
                    ygreen = image[i][j].rgbtGreen;
                    yblue = image[i][j].rgbtBlue;
                    pixels_used++;
                }
            }

            totalred = xred + yred;
            totalgreen = xgreen + ygreen;
            totalblue = xblue + yblue;

            tempred = totalred / pixels_used;
            tempgreen = totalgreen / pixels_used;
            tempblue = totalblue / pixels_used;

            image[i][j].rgbtRed = round(tempred);
            image[i][j].rgbtGreen = round(tempgreen);
            image[i][j].rgbtBlue = round(tempblue);
        }
    }
    return;
}