package puzzle.puzzleClasses;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.BufferedInputStream;
import java.io.IOException;

import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JMenu;
import javax.swing.JRadioButtonMenuItem;

public class Util{
/********************************************************sinal de um inteiro (1 ou -1)*/
	static int signal(double i){
		return (int)(i/Math.abs(i));	
	}
/***********************************************************Produto escalar*/
	static double Esc(double[] U,double[] V){
		return U[0]*V[0]+U[1]*V[1];
	}
/********************************************************Distância entre dois pontos*/	
	static double dist(Point P,Point Q){
		return Math.sqrt(Math.pow(P.x-Q.x,2)+Math.pow(P.y-Q.y,2));
	}
	static double dist(double[] P,double[] Q){
		return Math.sqrt(Math.pow(P[0]-Q[0],2)+Math.pow(P[1]-Q[1],2));
	}
/********************************************************** Norma de un vector*/
	static double norma(Point P){
		return Math.sqrt(Math.pow(P.x,2)+Math.pow(P.y,2));
	}
	static double norma(double[] V){
		return Math.sqrt(Math.pow(V[0],2)+Math.pow(V[1],2));
	}
/**************************************************************vector unitário de U*/
	static double[] uni(double[] U){
		double[] Result= new double[]{U[0]/norma(U),U[1]/norma(U)}; 
		return Result;	
	}
/************************************************************vector unitário de AB */
	static double[] uni(double[] A,double[] B){
		double[] Result= new double[2]; 
		double[] AB=new double[]{B[0]-A[0],B[1]-A[1]};
		Result=uni(AB);
		return Result;	
	}

/********************************************************angulo dados três pontos */
	static double angulo(double[] A,double[] Centro, double[] B){
		double result;
		double[] U=new double[]{A[0]-Centro[0],A[1]-Centro[1]};
		double[] V=new double[]{B[0]-Centro[0],B[1]-Centro[1]};
		result =Math.acos(Esc(U,V)/(norma(U)*norma(V)));
		if(result<0){result = 2*Math.PI+result;}
		return result;		
	}
/********************************************************angulo entre dois vectores*/
	  static double angulo(double[] U, double[] V){
		  double result;
		  result =Math.acos(Esc(U,V)/(norma(U)*norma(V)));
		  if(result<0){result = 2*Math.PI+result;}
		  return result;		
	  }

/*******************************************Função que transforma um string num inteiro*/
   static int StringToInt(String Str){
	  int result=0;
	  char[] textchar = new char[Str.length()];
	  textchar = Str.toCharArray();
	  for(int i=0; i<Str.length(); i++){
		  if(Character.isDigit(textchar[i])){
			  result = result+(int)(Math.pow((double) 10,(double) i))*Character.getNumericValue(textchar[textchar.length-i-1]);
		  }else{result=0;}
	  }
	  return result;
  }
/*********************************************Função que transforma um inteiro num string***/
	static String IntToString(int a){
		Integer aa=new Integer(a);
		return aa.toString();		
	}
/*********************************************Função que transforma um double num string***/
	static String DoubToString(double a){
		Double aa=new Double(a);
		return aa.toString();		
	}
/*********************************************Função que transforma um float num string***/
	static String FloatToString(float a){
		Float aa=new Float(a);
		return aa.toString();		
	}
/*********************************************Função que transforma um boolean num string***/
	static String BoolToString(boolean a){
		Boolean aa=new Boolean(a);
		return aa.toString();		
	}
  
/**********************************************Funçao que permite obter cores em HSV */
	static Color CorHSV(double h,double s, double v){
		return new Color(Color.HSBtoRGB((float)(h/360f),(float)(s/100f),(float)(v/100f)));
	}


/******************************************************************Seta*/
	static void Seta(Graphics2D g, Point P, Point Q){
		g.drawLine(P.x,P.y,Q.x,Q.y);
		
		g.rotate(Math.PI/5,Q.x,Q.y);
		g.drawLine(Q.x,Q.y,
					(int)(Q.x+20*((P.x-Q.x)/dist(Q,P))),
					(int)(Q.y+20*((P.y-Q.y)/dist(Q,P))));
		g.rotate(-Math.PI/5,Q.x,Q.y);
		
		g.rotate(-Math.PI/5,Q.x,Q.y);
		g.drawLine(Q.x,Q.y,
					(int)(Q.x+20*((P.x-Q.x)/dist(Q,P))),
					(int)(Q.y+20*((P.y-Q.y)/dist(Q,P))));
		g.rotate(Math.PI/5,Q.x,Q.y);
	}
  
/*********************************************************Objectos gráficos*****/
//	Rectângulos
	public static Rectangle Rect(Point Centro, int lado){
		return new Rectangle(Centro.x-lado/2, Centro.y-lado/2, lado,lado );	
	}
	public static Rectangle Rect(double[] Centro, double lado){
		return new Rectangle((int)(Centro[0]-lado/2), (int)(Centro[1]-lado/2),(int)lado,(int)lado );	
	}

//	Circulos e circunferencias
	public static void Circ(Graphics2D g, Point Centro, int raio){
		g.drawOval(Centro.x-raio,Centro.y-raio,2*raio,2*raio);
	}
	public static void fillCirc(Graphics2D g, Point Centro, int raio){
		g.fillOval(Centro.x-raio,Centro.y-raio,2*raio,2*raio);
	}
	public static void Circ(Graphics2D g, double[] Centro, int raio){
		g.drawOval((int)(Centro[0]-raio),(int)(Centro[1]-raio),2*raio,2*raio);
	}
	public static void fillCirc(Graphics2D g, double[] Centro, int raio){
		g.fillOval((int)(Centro[0]-raio),(int)(Centro[1]-raio),2*raio,2*raio);
	}

	public static void Circ(Graphics2D g, double[] Centro, double raio){
		g.drawOval((int)(Centro[0]-raio),(int)(Centro[1]-raio),(int)(2*raio),(int)(2*raio));
	}
	public static void fillCirc(Graphics2D g, double[] Centro, double raio){
		g.fillOval((int)(Centro[0]-raio),(int)(Centro[1]-raio),(int)(2*raio),(int)(2*raio));
	}

//	segmentos e rectas	
	public static void Line(Graphics2D g, double[] A, double[] B){
		g.drawLine((int)A[0],(int)A[1],(int)B[0],(int)B[1]);
	}
	public static void Recta(Graphics2D g, double[] A, double[] B){
		double[] AA=new double[2];
		double[] BB=new double[2];
		double[] Vuni=new double[2];
		Vuni=uni(A,B);
		AA[0]=A[0]+2000*Vuni[0];	AA[1]=A[1]+2000*Vuni[1];
		BB[0]=A[0]-2000*Vuni[0];	BB[1]=A[1]-2000*Vuni[1];
		Line(g,AA,BB);
	}
/************************************************Rotação de um ponto em torno de outro****/
	public static double[] Rot(double[] P, double[] C, double ang){
		double[] Imagem= new double[2];
		Imagem[0]=Math.cos(ang)*(P[0]-C[0])-Math.sin(ang)*(P[1]-C[1])+C[0];
		Imagem[1]=Math.sin(ang)*(P[0]-C[0])+Math.cos(ang)*(P[1]-C[1])+C[1];
		return Imagem;
	}
/************************************************ soluçõaes de equação de 2º grau****/
	public static double[] Equa2(double a, double b, double c){
		double[] Result=new double[2];
		Result[0]=(-b+Math.sqrt(b*b-4*a*c))/(2*a);
		Result[1]=(-b-Math.sqrt(b*b-4*a*c))/(2*a);
		return Result;
	}
/************************************************determinante de uma matriz 2x2 ****/
	public static double Det(double a, double b, double c, double d){
		return a*d-b*c;
	}
/************************************************projecçaõ de um vector U sobre V*/
	public static double Proj(double[] U, double[] V){
		double Result;
		Result=norma(U)*Math.cos(angulo(U,V));
		return Result;
	}
/************************************************Cor com transparência*/
	public static Color colorT(Color Cor, float a){
		return new Color((float)(Cor.getRed()/(double)255),(float)(Cor.getGreen()/(double)255),(float)(Cor.getBlue()/(double)255),a);
	}
	static Color CorRGB(double r, double g, double b){
		return new Color((float)(r/255),(float)(g/255),(float)(b/255));
	}

/*************************************************permuta de elementos num array*/
	public static void Permuta(int[][] array, int m, int n){
		int[] mm = array[m];
		int[] nn = array[n];
		if((m<array.length)&&(n<array.length)){
			array[m]=nn;
			array[n]=mm;
		}
	}
	public static void Permuta(int[] array, int m, int n){
		int mm = array[m];
		int nn = array[n];
		if((m<array.length)&&(n<array.length)){
			array[m]=nn;
			array[n]=mm;
		}
	}

/**transforma uma Image em BufferedImage */
	public static BufferedImage ImgToBuff(Image I, ImageObserver IObs){
		BufferedImage Result=null;
		Graphics2D g2;
		try{
			Result= new BufferedImage(I.getWidth(IObs),I.getHeight(IObs),BufferedImage.TYPE_INT_RGB);//(BufferedImage)Puzzle.frame.getContentPane().createImage(I.getSource());
			g2 = Result.createGraphics();
			g2.drawImage(I,0,0,IObs);
		}catch(IllegalArgumentException e){}
		
		return Result;
	}

/*************************************************************************************/
	protected static ImageIcon createAppletImageIcon(Class c, String path,
											  String description) {
		int MAX_IMAGE_SIZE = 630000; //Change this to the size of
									//your biggest image, in bytes.
		int count = 0;
		BufferedInputStream imgStream = new BufferedInputStream(
		   c.getResourceAsStream(path));
		if (imgStream != null) {
			byte buf[] = new byte[MAX_IMAGE_SIZE];
			try {
				count = imgStream.read(buf);
			} catch (IOException ieo) {
				System.err.println("Couldn't read stream from file: " + path);
			}

			try {
				imgStream.close();
			} catch (IOException ieo) {
				 System.err.println("Can't close file " + path);
			}

			if (count <= 0) {
				System.err.println("Empty file: " + path);
				return null;
			}
			return new ImageIcon(Toolkit.getDefaultToolkit().createImage(buf),
								 description);
		} else {
			System.err.println("Couldn't find file: " + path);
			return null;
		}
	}
	
	/**Cria um radioButtonGroup composto por radioButts */
	public static JMenu criaRadioButtonMenu(String nome, JRadioButtonMenuItem[] rbts, Color cor){
		JMenu Result = new JMenu(nome);
		Result.setBackground(new Color(cor.getRGB()));
		Result.setOpaque(true); 
		ButtonGroup RadioBG= new ButtonGroup();
		for (int i=0; i<rbts.length; i++){
			rbts[i].setBackground(cor);
			RadioBG.add(rbts[i]);
			Result.add(rbts[i]);
		}
		return Result;
	}
	
	public static void setaOr(Graphics2D g, double x, double y, double r, float stroke){
			g.setStroke(new BasicStroke(stroke));
			double alfa1=-180;
			double alfa2=120;
			double angBico= 25;
			double setaLength=0.7; //tamanho da seta em relação ao raio do arco
			double[] C = {x,y};
			double[] Bico = {C[0]+r*Math.cos(Math.toRadians(-alfa2)), C[1]+r*Math.sin(Math.toRadians(-alfa2))};
			double[] Tang_vect = {-(Bico[1]-C[1]), (Bico[0]-C[0])};
			double[] Tang_P = {Bico[0]+setaLength*Tang_vect[0], Bico[1]+setaLength*Tang_vect[1]};
			double[] E1 = Rot(Tang_P, Bico, Math.toRadians(3*angBico));
			double[] E2 = Rot(Tang_P, Bico, -Math.toRadians(angBico));
	    
			Line(g, E1, Bico);
			Line(g, E2, Bico);
			g.drawArc((int)(C[0]-r),(int)(C[1]-r),(int)(2*r), (int)(2*r), (int)alfa1, (int)(alfa2-alfa1));
	}


}