#include "../include/Image.h"

// /***********************BIG SIX**********************/

Image::Image(int w, int h, unsigned char* d):width(w),height(h) {

data = std::unique_ptr<unsigned char []>(d);

}

Image::Image():width(0),height(0) {

// data = {u_char(0)};

}

Image::~Image() {

this->width = 0;

this->height = 0;

this->data.~unique_ptr();

}

Image::Image(const Image &other) {

}

Image &Image::operator=(const Image &other) {

this->width = other.width;

this->height = other.height;

unsigned char *buffer = new unsigned char[width * height];

data = std::unique_ptr<unsigned char[]>(buffer);

Image::iterator beg = this->begin(), end = this->end();

Image::iterator inStart = other.begin(), inEnd = other.end();

while (beg != end)

{

*beg = *inStart;

++beg;

++inStart;

}

return *this;

}

Image::Image(Image &&other):width(0),height(0) {

}

Image &Image::operator=(Image &&other) {

//Move assignment operator

if(this==&other){

}else{

this->width = 0;

this->height = 0;

this->data = nullptr;

this->width = other.width;

this->height = other.height;

unsigned char *buffer = new unsigned char[width * height];

data = std::unique_ptr<unsigned char[]>(buffer);

this->data = std::move(other.data);

other.width = 0;

other.height = 0;

other.data = nullptr;

return *this;

}

}

/****************BINARY OPERATOR OVERLOADING***************/

bool Image::operator+(const Image &other){

//addition of two images (I1 + I2)

if(rangeCheck(other)==false)return false;

iterator iter_to_add = other.begin();

for (iterator iter_result = this->begin(); iter_result != this->end(); ++iter_result)

{

u_char value;

value = *iter_result + *iter_to_add;

*iter_result = clamp(value);

iter_to_add++;

}

}

bool Image::operator-(const Image &other){

if(rangeCheck(other)==false)return false;

iterator iter_to_subtract = other.begin();

for (iterator iter_result = this->begin(); iter_result != this->end(); ++iter_result)

{

u_char value;

value = *iter_to_subtract - *iter_result;

*iter_result = clamp(value);

iter_to_subtract++;

}

}

bool Image::operator!(){

for (iterator iter_result = this->begin(); iter_result!=this->end(); ++iter_result)

{

*iter_result = 255-*iter_result;

}

}

bool Image::operator/(const Image &other){

if(rangeCheck(other)==false)return false;

iterator iter_to_mask = other.begin();

for (iterator iter_result = this->begin(); iter_result != this->end(); ++iter_result)

{

*iter_to_mask == u_char(255)? :*iter_result = u_char(0);

iter_to_mask++;

}

}

bool Image::operator*(const int f){

for (iterator iter_result = this->begin(); iter_result != this->end(); ++iter_result)

{

*iter_result > u_char(f) ? *iter_result=255:*iter_result=0;

}

}

bool Image::operator%(const std::string file){

//filter with % (filter) (I1 % filter)

Filter f(file, *this);

this->data = std::unique_ptr<unsigned char[]>((unsigned char *)f.filter_image());

}

///////////////////////////////////////////////////

/****************IO OPERATOR OVERLOADING***************/

void Image::operator<<(const std::string file) {

load(file);

}

void Image::operator>>(const std::string file) {

save(file);

}

bool Image::operator==(const Image &other) const{

if(width==other.width && height == other.height){

int size_of_data = other.width*other.height;

unsigned char* this_buffer = data.get();

unsigned char* other_buffer = other.data.get();

for(int i = 0; i<size_of_data-1;i++){

if(this_buffer[i]!=other_buffer[i]){

std::cout << int(this_buffer[i]) << " vs " << int(other_buffer[i])<<" i: "<<i;

return false;

}

}

return true;

}

return false;

}

bool Image::operator!=(const Image &other) const{}

///////////////////////////////////////////////////

void Image::load(std::string input_name) {

}

void Image::save(std::string output_name) {

}

unsigned char Image::clamp(unsigned char pixel){

}

bool Image::rangeCheck(const Image& other)const{

return (this->width==other.width&&this->height==other.height);

}