/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   modify.c                                           :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: Diana <Diana@student.42.fr>                +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2019/03/04 21:55:30 by rfunk             #+#    #+#             */
/*   Updated: 2019/03/20 11:48:07 by Diana            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "../includes/fractol.h"

//------------ADITIONALS-------------
	unsigned rgb2hex(rgb RGB)
	{
		return (RGB.r<<16) | (RGB.g<<8) | RGB.b;
	}

	hsv rgb2hsv(rgb in)
	{
		hsv         out;
		double      min, max, delta;

		min = in.r < in.g ? in.r : in.g;
		min = min  < in.b ? min  : in.b;

		max = in.r > in.g ? in.r : in.g;
		max = max  > in.b ? max  : in.b;

		out.v = max;                                // v
		delta = max - min;
		if (delta < 0.00001)
		{
			out.s = 0;
			out.h = 0; // undefined, maybe nan?
			return out;
		}
		if( max > 0.0 ) { // NOTE: if Max is == 0, this divide would cause a crash
			out.s = (delta / max);                  // s
		} else {
			// if max is 0, then r = g = b = 0
			// s = 0, h is undefined
			out.s = 0.0;
			out.h = NAN;                            // its now undefined
			return out;
		}
		if( in.r >= max )                           // > is bogus, just keeps compilor happy
			out.h = ( in.g - in.b ) / delta;        // between yellow & magenta
		else
		if( in.g >= max )
			out.h = 2.0 + ( in.b - in.r ) / delta;  // between cyan & yellow
		else
			out.h = 4.0 + ( in.r - in.g ) / delta;  // between magenta & cyan

		out.h *= 60.0;                              // degrees

		if( out.h < 0.0 )
			out.h += 360.0;

		return out;
	}

	rgb hsv2rgb(hsv HSV)
	{
		rgb RGB;
		double H = HSV.h, S = HSV.s, V = HSV.v,
				fract;
		int P, Q, T;

		(H == 360.)?(H = 0.):(H /= 60.);
		fract = H - floor(H);
		P = (int)255*V*(1. - S);
		Q = (int)255*V*(1. - S*fract);
		T = (int)255*V*(1. - S*(1. - fract));
		V *= 255;
		if      (0. <= H && H < 1.)
			RGB = (rgb){.r = V, .g = T, .b = P};
		else if (1. <= H && H < 2.)
			RGB = (rgb){.r = Q, .g = V, .b = P};
		else if (2. <= H && H < 3.)
			RGB = (rgb){.r = P, .g = V, .b = T};
		else if (3. <= H && H < 4.)
			RGB = (rgb){.r = P, .g = Q, .b = V};
		else if (4. <= H && H < 5.)
			RGB = (rgb){.r = T, .g = P, .b = V};
		else if (5. <= H && H < 6.)
			RGB = (rgb){.r = V, .g = P, .b = Q};
		else
			RGB = (rgb){.r = 0., .g = 0., .b = 0.};

		return RGB;
	}

	int		get_light(int start, int end, double percentage)
	{
		return ((int)((1 - percentage) * start + percentage * end));
	}

	double	percent(int start, int end, int current)
	{
		double placement;
		double distance;

		placement = current - start;
		distance = end - start;
		return ((distance == 0) ? 1.0 : (placement / distance));
	}

	// todo maybe remove
	int		swap_bits_if(int color)
	{
		int	bit1;
		int	bit2;

		bit1 = (color & 0xFF) >> 1;
		bit2 = (color & 0xFF) >> 2;
		if (bit1 > bit2)
		{
			color = bit1;
			bit1 = bit2;
			bit2 = color;
			color = ((bit1 << 2) | (bit2 << 1));
		}

		return (color);
	}

//-------------------------------------

//----------COLOR AlGORITHMS-----------

// multi gradient
int	hsv_color(t_screen *screen, int it, int arg)
{
	hsv h;
	rgb	RGB;
	int	hue;
	int temp = arg;//remove
	temp++;

	//replace shit
	if (screen->color_scheme.hue_offset >= 360)
		screen->color_scheme.hue_offset -= 360;
	else if (screen->color_scheme.hue_offset < 0)
		screen->color_scheme.hue_offset += 360;
	hue = ((double)it/screen->itrs * 360) + screen->color_scheme.hue_offset;
	hue >= 360 ? hue -= 360 : 0;
	hue < 0 ? hue += 360 : 0;
	h = (hsv) { hue, .s = screen->color_scheme.saturation, .v = screen->color_scheme.brightness_v};
	RGB = (hsv2rgb(h));
	return (rgb2hex(RGB));
}

// color jump (one spector)
int	color_jump(t_screen *screen, int it, int arg)
{
	hsv h;
	rgb	RGB;
	int temp = arg;//remove
	temp++;
	double tmp;

	//replace shit
	if (screen->color_scheme.hue_offset >= 360)
		screen->color_scheme.hue_offset -= 360;
	else if (screen->color_scheme.hue_offset < 0)
		screen->color_scheme.hue_offset += 360;
	tmp = ((double)(it % 10))/10;
	h = (hsv) { screen->color_scheme.hue_offset, .s = tmp, .v = tmp};
	RGB = (hsv2rgb(h));
	return (rgb2hex(RGB));
}


int	color_jump2(t_screen *screen, int it, int arg)
{
	hsv h;
	rgb	RGB;
	int	hue;
	int temp = arg;//remove
	temp++;

	//replace shit
	if (screen->color_scheme.hue_offset >= 360)
		screen->color_scheme.hue_offset -= 360;
	else if (screen->color_scheme.hue_offset < 0)
		screen->color_scheme.hue_offset += 360;
	hue = ((it % 5)) + screen->color_scheme.hue_offset;
	hue >= 360 ? hue -= 360 : 0;
	hue < 0 ? hue += 360 : 0;
	h = (hsv) { 60, .s = screen->color_scheme.saturation, .v = ((double)(it % 10))/10};
	RGB = (hsv2rgb(h));
	return (rgb2hex(RGB));
}

// absolute gradient design (+ inverted maybe)
int		absolute_gradient(t_screen *screen, int it, int color)
{
	hsv 	h;
	rgb		RGB;
	double	br_v;

	int temp = color;
	temp++;//remove

	//replace shit
	if (screen->color_scheme.hue_offset >= 360)
		screen->color_scheme.hue_offset -= 360;
	else if (screen->color_scheme.hue_offset < 0)
		screen->color_scheme.hue_offset += 360;
	if (screen->color_scheme.direction == 1)
		br_v = 1 - (double)it/screen->itrs;
	else
		br_v = (double)it/screen->itrs;
	h = (hsv) { screen->color_scheme.hue_offset, .s = screen->color_scheme.saturation, .v = br_v};
	RGB = (hsv2rgb(h));
	return (rgb2hex(RGB));
}

// this method can be use only if one ore more R G B bytes are FF (voodoo magic)
int		material_des(t_screen *screen, int iteration, int color)
{
	rgb	RGB;
	double	percentage;

	percentage = percent(0,screen->itrs / screen->extrude, iteration);
	while (percentage > 1)
		percentage -= 1;
	RGB.r = get_light((color >> 16) & 0xFF, (0 >> 16) & 0xFF, percentage);
    RGB.g = get_light((color >> 8) & 0xFF, (0 >> 8) & 0xFF, percentage);
    RGB.b = get_light(color & 0xFF, 0 & 0xFF, percentage);
	return (((rgb2hex(RGB) & color)));
}

int	(*funcs [])(t_screen*, double, double) = {
	julia,
	mandelbrot
};

int	(*color_scheme [])(t_screen*, int, int) = {
	hsv_color,
	absolute_gradient,
	color_jump,
	material_des
};

void	*foreach_pixel(void *scn)
{
	t_screen	*screen;
	int			i;
	int			tmp;
	int			it;

	screen = (t_screen *)scn;
	i = 0;
	while (i < screen->width)
	{
		tmp = screen->start_r;
		while (tmp < screen->end_r)
		{
			if ((it = funcs[screen->render_fr](screen, i, tmp)))
				set_pixel(screen, i + screen->margin_x, tmp + screen->margin_y,
				color_scheme[screen->color_scheme.index](screen, it, screen->color_scheme.base_color));
			else
				set_pixel(screen, i + screen->margin_x, tmp + screen->margin_y, 0);
			tmp++;
		}
		i++;
	}
	return (screen);
}