#include <stdio.h>
#include <string.h>
#include <math.h>
#include "varios.hpp"

Cor_rgb::Cor_rgb(int _r, int _g, int _b)
{
  r= Acerta(_r);
  g= Acerta(_g);
  b= Acerta(_b);
}

void Cor_rgb::read( FILE *fp )
{
  double _r, _g, _b;
  fscanf( fp, " %lf %lf %lf ", &_r, &_g, &_b );
  r= Acerta((int)_r);
  g= Acerta((int)_g);
  b= Acerta((int)_b);
}

unsigned char Cor_rgb::Acerta(int x)
{
  if ( x<0 )
    return (unsigned char)0;
  if ( x>255 )
    return (unsigned char)255;
  return (unsigned char)x;
}

void Cor_rgb::Atribui(int _r, int _g, int _b)
{
  r= Acerta(_r);
  g= Acerta(_g);
  b= Acerta(_b);
}
  
void Cor_rgb::Copia(Cor_rgb origem)
{
  r= origem.R();
  g= origem.G();
  b= origem.B();
}

Cor_rgb Cor_rgb::operator+( Cor_rgb& cor )
{
  Cor_rgb result;
  int t;
  t = cor.r + (int)r;
  result.r = Acerta( t );
  t = cor.g + (int)g;
  result.g = Acerta( t );
  t = cor.b + (int)b;
  result.b = Acerta( t );
  return result;
}

Cor_rgb Cor_rgb::operator*( Cor_rgb& cor )
{
  Cor_rgb result;
  result.r = Acerta( (int) ( (double) r * ( (double) cor.r / 255 ) ) );
  result.g = Acerta( (int) ( (double) g * ( (double) cor.g / 255 ) ) );
  result.b = Acerta( (int) ( (double) b * ( (double) cor.b / 255 ) ) );
  return result;
}

Cor_rgb Cor_rgb::operator*( double ind )
{
  Cor_rgb result;
  result.r = Acerta( (int) ( (double) r * ind ) );
  result.g = Acerta( (int) ( (double) g * ind ) );
  result.b = Acerta( (int) ( (double) b * ind ) );
  return result;
}

// implementação da imagem
Imagem::Imagem(int _w, int _h) {
	if (_w>0 && _h>0){
		w=_w; 
		h=_h; 
		pixels = new Cor_rgb [w*h]; 
	}
	else{
		w=0; 
		h=0; 
		pixels = 0; 
	}
}

Imagem::Imagem( char *file_name )
{
  FILE *fp;
  char line[80];
  unsigned char pixel[3];
  int i,j,k,max;

  pixels = NULL;
  
  fp = fopen(file_name, "rb");
  if (fp == NULL){
     printf("could not read from %s\n",file_name);
	 w=0; h=0; pixels=NULL;
     return;
  }
  fgets(line,80,fp);

  if(strcmp(line,"P6\n"))
  {
     return;
  }
  while (fscanf( fp, " %d ", &w ) != 1)
	  fgets(line, 80, fp);
  while (fscanf( fp, " %d ", &h ) != 1)
	  fgets(line, 80, fp);
  while (fscanf( fp, " %d", &max ) != 1)
	  fgets(line, 80, fp);
  fgetc(fp);

  pixels = new Cor_rgb [w*h];

  //le invertendo as linhas:
  for ( i=h-1; i>=0; i-- )
    for ( j=0; j<w; j++ )
    {
      k = i*w + j;
      fread( pixel, 3, 1, fp );
      pixels[k].Atribui(pixel[0],pixel[1],pixel[2]);
    }

  fclose(fp);
  return;
}

Imagem::Imagem (int new_w, int new_h, Imagem& old_img)
{
 w = new_w;
 h = new_h;
 pixels = new Cor_rgb [w*h];

 if (old_img.Valida()) {
	  int i, j, i_old, j_old, k, k_old;
	  int old_w = old_img.Colunas();
	  int old_h = old_img.Linhas();
     //copia fazendo os ajustes
      for ( i=0; i<h; i++ )
		  for ( j=0; j<w; j++ )
			  {
			  i_old = (int) ((double) old_h * i / h);
			  j_old = (int) ((double) old_w * j / w);

			  k = i*w + j;
			  k_old = i_old*old_w+j_old;

			  pixels[k].Copia(old_img.pixels[k_old]);

			  }
 }
 else {
	  int i,j,k;
	  Cor_rgb black(0,0,0);
      for ( i=0; i<h; i++ )
		  for ( j=0; j<w; j++ )
			  {
			  k = i*w + j;
			  pixels[k].Copia(black);
			  }
 }
}

void Imagem::Resize (int new_w, int new_h)
{
  if (pixels!=0) {
    int old_w=w;
    int old_h=h;
    Cor_rgb * new_pixels;

    new_pixels = new Cor_rgb [new_w*new_h];
    int i_new, j_new, i_old, j_old, k_new, k_old;

     //copia fazendo os ajustes
    for ( i_new=0; i_new <new_h; i_new++ ){
      for ( j_new=0; j_new<new_w; j_new++ ) {
			  i_old = (int) ((double) old_h * i_new / new_h);
			  j_old = (int) ((double) old_w * j_new / new_w);

			  k_new = i_new*new_w + j_new;
			  k_old = i_old*old_w + j_old;

			  new_pixels[k_new].Copia(pixels[k_old]);

			  }
    }
    w = new_w;
    h = new_h;
    delete [] pixels;
    pixels = new_pixels;
  }
}


bool Imagem::SalvaPPM( char *arquivo )
{
  FILE * arqppm;
  int i,j, indice;
  int cores=255;

  strcat(arquivo,".ppm");
  if ((arqppm = fopen(arquivo, "wb")) == NULL)
  {
    printf("\nNão foi possivel abrir o arquivo %s\n",arquivo);
    return false;
  }

  //cabeçalho de um arquivo .ppm
  fprintf(arqppm,"P6\n%d %d\n%d\n", w, h, cores);

  //gravando invertendo as h:
  for ( i=h-1; i>=0; i-- )
    for ( j=0; j<w; j++ )
    {
      indice = i*w + j;
      fprintf(arqppm,"%c%c%c", pixels[indice].R(), pixels[indice].G(), pixels[indice].B());
    }

  printf("\nO arquivo %s foi gerado com sucesso.\n",arquivo);

  fclose(arqppm);
  return true;
}

// implementação do Vetor_3D

void Vetor_3D::Copia(Vetor_3D origem)
{
  x = origem.x;
  y = origem.y;
  z = origem.z;
}

void Vetor_3D::read( FILE *fp )
{
  fscanf( fp, " %lf %lf %lf ", &x, &y, &z );
}

void Vetor_3D::Atribui(double _x, double _y, double _z)
{
  x = _x;
  y = _y;
  z = _z;
}

Vetor_3D Vetor_3D::operator+( const Vetor_3D& vet ) const
{
  return Vetor_3D( x+vet.x, y+vet.y, z+vet.z );
}

Vetor_3D Vetor_3D::operator-( const Vetor_3D& vet ) const
{
  return Vetor_3D( x-vet.x, y-vet.y, z-vet.z );
}

double Vetor_3D::operator*( const Vetor_3D& vet ) const
{
  return ( x*vet.x + y*vet.y + z*vet.z );
}

Vetor_3D Vetor_3D::operator^( const Vetor_3D& vet ) const
{
  return Vetor_3D( y*vet.z - z*vet.y,  z*vet.x - x*vet.z, x*vet.y - y*vet.x );
}

Vetor_3D Vetor_3D::operator*( const double n ) const
{
  return Vetor_3D(x*n, y*n, z*n);
}

Vetor_3D Vetor_3D::operator/( const double n ) const
{
  return Vetor_3D(x/n, y/n, z/n);
}

Vetor_3D Vetor_3D::operator-() const
{
  return Vetor_3D(-x, -y, -z);
}

double Vetor_3D::Comprimento()
{
  return ( (double)sqrt( x*x + y*y + z*z ) );
}

//divide cada componente pelo comprimento.
void Vetor_3D::Normaliza()
{
  double aux;
  aux = Comprimento();
  if (aux < ZERO) aux = ZERO;
  x = x/aux;
  y = y/aux;
  z = z/aux;
}

// implementação do Raio
Raio::Raio()
{}

Raio::Raio(Vetor_3D _origem, Vetor_3D _destino)
{
  origem  = _origem;
  destino = _destino;
  direcao = destino - origem;
}

//Retorna o ponto para este t aplicado na função paramétrica
Vetor_3D Raio::QualPonto(double t)
{
  Vetor_3D ponto;
  
  ponto = origem + t*direcao;

  return ponto;
}

void Raio::Atribui(Vetor_3D _origem, Vetor_3D _destino)
{
  origem  = _origem;
  destino = _destino;
  direcao = destino - origem;
}