package puzzle.puzzleClasses;

import java.awt.BasicStroke;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;

import jv.objectGui.PsImage;

class Cria_BuffImgs{

	static int W;
	static int H;
	double w;
	double h;
	Graphics2D g2;
	ImageIcon IIcon;
	static BufferedImage bi;
	static BufferedImage[][] bis; 
	
	/**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);
			g2 = Result.createGraphics();
			g2.drawImage(I,0,0,IObs);
		}catch(IllegalArgumentException e){}
		
		return Result;
	}
	
	/**Cria uma ImageIcon com as dimensões pretendidas: W e H.*/
	public static ImageIcon cropIcon(String caminhoImg,int W,int H){
		BufferedImage image = ImgToBuff((new PsImage(caminhoImg)).getImage(),null);
		double fEW = W/((double)image.getWidth()), fEH = ((double)H/image.getHeight());//factorEscala
			
		BufferedImage Result= new BufferedImage(W,H,BufferedImage.TYPE_INT_RGB);
		AffineTransform trans = new AffineTransform();	trans.scale(fEW,fEH);
		Graphics2D g2; g2 = Result.createGraphics(); g2.fillRect(0, 0, (int)(W), (int)(H));
		g2.drawImage(image,trans, null);
			
		ImageIcon img = new ImageIcon();   img.setImage(Result);
		
		return img;
	}
	
	/**Cria uma ImageIcon com as dimensões pretendidas: W e H.*/
	public static BufferedImage cropIconB(ImageIcon icon,int W,int H){
		BufferedImage image = ImgToBuff(icon.getImage(),null);
		double fEW = W/((double)image.getWidth()), fEH = ((double)H/image.getHeight());//factorEscala
			
		BufferedImage Result= new BufferedImage(W,H,BufferedImage.TYPE_INT_RGB);
		AffineTransform trans = new AffineTransform();	trans.scale(fEW,fEH);
		Graphics2D g2; g2 = Result.createGraphics(); g2.fillRect(0, 0, (int)(W), (int)(H));
		g2.drawImage(image,trans, null);
		
		return Result;
	}
	
	public Cria_BuffImgs(String path, int M, int N){
			try{
				IIcon=new ImageIcon(path);
				bi= Util.ImgToBuff(IIcon.getImage(),IIcon.getImageObserver());
				if((IIcon.getImage()).getWidth(null)>(Dados.MaxW)||(IIcon.getImage()).getHeight(null)>(Dados.MaxH)){
					//bi=bi.getSubimage(0,0,(Dados.MaxW-6), (Dados.MaxH-50));
					//bi = cropIconB(IIcon,(Dados.MaxW-6),(Dados.MaxH-50));
				}else {
					bi= Util.ImgToBuff(IIcon.getImage(), IIcon.getImageObserver());
				}
				bis=Divide_Img(bi, M, N);
			}catch(Exception e){System.out.println("Insira uma imagem que no máximo tenha o tamanho de "+(Dados.MaxW-6)+"x"+(Dados.MaxH-50));}
	}
	
	public Cria_BuffImgs(Class c, String path, int M, int N ) {
		IIcon = Util.createAppletImageIcon(c, path, "");
		bi= Util.ImgToBuff(IIcon.getImage(), IIcon.getImageObserver());
		if(bi.getWidth()>(Dados.MaxW-6)||bi.getHeight()>(Dados.MaxH-50)){
			bi=bi.getSubimage(0,0,(Dados.MaxW-6), (Dados.MaxH-50));
		}
		bis=Divide_Img(bi, M, N);
	}
	public Cria_BuffImgs(int Num_ou_Pontos,int M, int N, int[] dim) {
		bi=Cria_BuffImgs.Cria_Buff_Img(Num_ou_Pontos, M, N, dim);
		
		bis=Divide_Img(bi, M, N);		
	}
	
	/**Método que parte a imagem aos bocados*/
	public static BufferedImage[][] Divide_Img(BufferedImage bi, int M, int N){
		BufferedImage[][] Result = new BufferedImage[M*N][2];
		W=bi.getWidth();
		H=bi.getHeight();
		
		int Conta=1;
		Result[0]=null;
		for(int i=0;i<N; i++){
			for(int j=0; j<M&&Conta<M*N; j++){
				Result[Conta][0]= bi.getSubimage((j)*(W/M),(i)*(H/N),(int)(W/M),(int)(H/N));
				Result[Conta][1]= Inv_BI(Result[Conta][0]);
				Conta++;
			}
		}		
		return Result;
	}
	
	/**Importa a imagem indicada em path*/
	public static BufferedImage ImportImg(String path){
		BufferedImage BI = null;
		File f= new File(path);
		try{BI = ImageIO.read(f);
		}catch(IOException e){
			System.out.print("não encontro a imagem!!");}	
		return BI;	
	}
	
	/**Retorna uma imagem reflectida na vertical a partir de bi*/
	public static BufferedImage Inv_BI(BufferedImage bi){
		BufferedImage Result;
		
		int W=bi.getWidth();	int H=bi.getHeight();
		AffineTransform trans = new AffineTransform();
		trans.translate(0, H);
		trans.scale(1,-1);
		Graphics2D g2d;
		
		Result = (BufferedImage)AppletPuzzle.ff.createImage(W, H);
		g2d = Result.createGraphics();
		g2d.drawImage(bi,trans, null);
		return Result;
	}

	/**
	 * Retorna um BufferedImage de dimensão dim com 
	 * números ou pontos (Num_ou_Pontos)
	 * dividida em MxN
	*/
	public static BufferedImage Cria_Buff_Img(int num_ou_pts_ou_setas, int M, int N, int[] dim){
		int W = dim[0];		int H = dim[1];
		double w = W/(double)M;		double h = H/(double)N;
		int GrossRect = (int)(Math.min(w,h)/15);
		
		BufferedImage BI;
		Graphics2D G2D;
		
		BI = (BufferedImage)AppletPuzzle.ff.createImage(W, H);
		G2D = BI.createGraphics();
		G2D.setFont(new Font("", Font.PLAIN, (int)(1.5*Math.min(w,h))/3));
		G2D.setColor(Dados.NumFundo);
		G2D.fillRect(0, 0, W, H);
		int Conta=1;
		for(int i=0; i<N; i++){
			for (int j=0; j<M; j++){
				G2D.translate(j*w, i*h);
				G2D.setStroke(new BasicStroke(GrossRect));
				G2D.setColor(Dados.NumLinha);
				G2D.drawRoundRect((int)(GrossRect),(int)(GrossRect), 
								(int)(w-(2*GrossRect)), (int)(h-(2*GrossRect)), 2,2);
				G2D.setColor(Dados.NumPonto);
				if(num_ou_pts_ou_setas==2){
					Cria_BuffImgs.Setas(G2D, w, h, Conta);
				}else{
				if(num_ou_pts_ou_setas==1){
				    Cria_BuffImgs.Bolas(G2D, w, h, Conta);
				}else{
					G2D.fillOval((int)(3*GrossRect),(int)(3*GrossRect),(int)(GrossRect),(int)(GrossRect));
					G2D.setColor(Dados.NumStr);
				
					G2D.drawString(Util.IntToString(Conta),
									(int)(w/2-((G2D.getFont().getSize()*Util.IntToString(Conta).length())/4)),
									(int)(h/2+G2D.getFont().getSize()/3));
				}}
				G2D.translate(-j*w, -i*h);
				Conta++;
			}
		}
		return BI;
	}

	/**Desenha n bolas num rectângulo wxh tipo "Dados"*/
	static void Bolas(Graphics2D g2, double w, double h, double n){
		double raio = Math.min(w,h)/30;
		double separa;
		double separa2;
		if(n%2==0){
			separa = (w)/(n/2+1);
			separa2 = (h)/3;
			for(int i=1; i<n/2+1; i++){
				g2.fillOval((int)((i*separa)-raio), (int)(separa2-raio), (int)(2*raio),(int)(2*raio));
				g2.fillOval((int)((i*separa)-raio), (int)(2*separa2-raio),(int)(2*raio),(int)(2*raio));
			}
		}else{
			separa = (w)/(n/2+0.5);
			separa2 = (h)/4;
			for(int i=1; i<n/2+0.5; i++){
				g2.fillOval((int)((i*separa)-raio), (int)(separa2-raio), (int)(2*raio),(int)(2*raio));
				g2.fillOval((int)((i*separa)-raio), (int)(3*separa2-raio),(int)(2*raio),(int)(2*raio));
			}
			g2.fillOval((int)(w/2-raio), (int)(h/2-raio), (int)(2*raio),(int)(2*raio));
		}
	}
	
	static void Setas(Graphics2D g2, double w, double h, double n){
		double raio = Math.min(w,h)/14; if(AppletPuzzle.simples){ raio = Math.min(w,h)/15;}else if(AppletPuzzle.prismas){raio = Math.min(w,h)/14;}
		double separa;
		double separa2;
		float grossura = 2.0f; if(AppletPuzzle.simples){ grossura = 2.5f;}else if(AppletPuzzle.prismas){ grossura = 0.3f; }
		if(n%2==0){
			separa = (w)/(n/2+1);
			separa2 = (h)/3;
			for(int i=1; i<n/2+1; i++){
			    Util.setaOr(g2, (i*separa),separa2, raio, grossura);
			    Util.setaOr(g2, (i*separa),2*separa2, raio, grossura);
			}
		}else{
			separa = (w)/(n/2+0.5);
			separa2 = (h)/4;
			for(int i=1; i<n/2+0.5; i++){
			    Util.setaOr(g2, (i*separa),separa2, raio, grossura);
		        Util.setaOr(g2, (i*separa),3*separa2, raio, grossura);
			}
			Util.setaOr(g2, (w/2),(h/2), raio, grossura);
		}
	}

}