package cat;

/**
 * @author  Roger Olivella
 * @version 1.0
 *
 * Development Environment        :  JBuilder, Eclipse

 * Name of the Application        :  Interfase2.java
 * Creation/Modification History  :
 *
 *    Roger O.                Creat en el transcurs de l'any 2005. Acabat el desembre del 
 *    						  mateix any. 
 *    Roger O.                28/03/06 Modified: afegit al constructor el color de la lletra 
 *    						  i el fons del poema. 
 *    Roger O.                04/04/06: correcció de les posicions a on dibuixa les lletres.
 *
 */

import java.util.*;

import java.awt.*;
import java.awt.image.*;
//import java.awt.geom.*;

public class Kernel {

  double dCentreX,dCentreY;//Coordenades del centre antigues
  double dNouCentreX = 0;//Coordenada X del centre recalculada
  double dNouCentreY = 0;//Coordenada Y del centre recalculada
  double dAngle = 0;//Angle de dibuix de la tortuga
  float fXactual,fYactual=0;
  float fMinAbsolutX,fMaxAbsolutX,fMinAbsolutY,fMaxAbsolutY=0;
  float fAlturaLletra;//definida tamb? a PostProcess
  int iAmple,iAltura;//Dimensions de la imatge final
  int iFontSize;//Mida de la lletra
  int iNumCaractMaxOrdres = 0;//Var. de carregaBibliotecaOrdresTortuga
  int p, q, r, l,m = 0;//Var. de llegeix
  int iConrRectDib = 0; //Contador de rectes dibuixades
  /*Es fixa que el nombre de divisions (all? on s'escriur?n les lletres)
  sigui 7. Per mantenir la multiplicitat de 5,
  es far? que per 7 divisions dins un mateix segment de recta, s'omplin nom?s 5 espais
  amb lletres. El primer i ?ltim espai es deixen en blanc. Aix? ?nicament es fa per millorar
  substancialment la llegibilitat del text*/
  int iNombreDivisions = 7;
  int iNombreEspaisBuits = 2;
  int iFinalText = iNombreDivisions - 2;
  int iIniciText = 0;//Variable de control de la lletra en strbTextTabulaSmaragdina
  boolean bFlagDuesIgualsInici, bFlagDuesIgualsFinal = false;
  //boolean bFlagFileNotFound=false;
  String strFontType;//Tipus de la font de la lletra
  String strDirOutputImg;//Direct?ri d'output de la imatge
  String strMissatgeRetorn;
  //Definici? del text a escriure:
  //StringBuffer strbTextTabulaSmaragdina = new StringBuffer("quodestinferiusestsicutquodestsuperiusetquodestsuperiusestsicutquodestinferiuset");
  StringBuffer strbTextTabulaSmaragdina=new StringBuffer("QUODESTINFERIUSESTSICUTQUODESTSUPERIUSETQUODESTSUPERIUSESTSICUTQUODESTINFERIUSET");
  //StringBuffer strbTextTabulaSmaragdina=new StringBuffer("OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO");
  BufferedImage bi;
  Graphics2D g2d;
  FontMetrics fm;
  ArrayList arrayBibliotecaOrdresTortuga = new ArrayList();
  ArrayList arrayBibliotecaOp = new ArrayList();
  ArrayList arrayCadenaLlegida = new ArrayList();
  ArrayList arrayOrdresTortuga = new ArrayList();

  //Constructor per defecte
  public Kernel (){
  }

  //Constructor
  Kernel (double dCX,double dCY,int iAlt,int iAmp,String strDir, String strFontype, int iFontsiz, Color colorLletra, Color colorFons,int numIteracio) {
    this.dCentreX=dCX;
    this.dCentreY=dCY;
    this.iAltura=iAlt;
    this.iAmple=iAmp;
    this.strDirOutputImg=strDir;
    this.strFontType=strFontype;
    this.iFontSize=iFontsiz;
    //Si és >=3, fen servir el tipus binàri per no induïr un OutOfMemoryError.
    if(numIteracio>=3){
    	bi = new BufferedImage(iAmple,iAltura,BufferedImage.TYPE_BYTE_BINARY);
    } else {
    	bi = new BufferedImage(iAmple,iAltura,BufferedImage.TYPE_INT_RGB);
    }
    g2d = bi.createGraphics();
    g2d.setColor(colorFons);//Fixa el color del background de la imatge 
    g2d.fillRect(0,0,iAmple,iAltura);
    //Es fixa el tipus i mida de la lletra.
    Font f;
    f = new Font(strFontType, Font.PLAIN, iFontSize);
    g2d.setFont(f);
    g2d.setColor(colorLletra);//color lletra. 
    fm=g2d.getFontMetrics(f);
  }

  /*M?tode SUBSTITUEIX: Agafa la "rewriting rule" i la inserta a la n-?ssima iteraci? segons el car?cter
   que es vol que trobi*/
  public String substitueix(String strRwRule,String strNiteracio,String strCaracterBuscat){
    String strChunkNiteracio = "";//Cadena que cont? un tro? o "chunk" de la cadena resultant de la n-?ssima iteraci?
    StringBuffer buffResultat = new StringBuffer();//Buffer de Strings d'output
    carregaBibliotecaOp();
    for (int i = 0; i < strNiteracio.length(); i++) {
      strChunkNiteracio=strNiteracio.substring(i, i + 1);
      if (strCaracterBuscat.equals(strChunkNiteracio)) {
        buffResultat.append(strRwRule);
      }
      else {
        for (int j = 0; j < arrayBibliotecaOp.size(); j++) {
          String strComponentArrayBiblioOp=arrayBibliotecaOp.get(j).toString();
          if (strChunkNiteracio.equals(strComponentArrayBiblioOp)){
            buffResultat.append(strComponentArrayBiblioOp);
          }
        }
      }
    }
    return buffResultat.toString();
  }

  //M?tode LLEGEIX
  public ArrayList llegeix(String strRwRule){
    carregaBibliotecaOrdresTortuga();//Es carrega l'array d'ordres de tortuga
    /*Loop que examina cada ordre del RwRule, i quan en troba una reconeixible (segons la biblioteca
     d'operadors), la separa i guarda en una certa ubicaci? al arrayOrdresTortuga*/
    for(p=0;p<strRwRule.length();p++){
      for(q=0;q<iNumCaractMaxOrdres;q++){
          String strChunkRwRule=strRwRule.substring(p,p+q+1);
          for(r=0;r<arrayBibliotecaOrdresTortuga.size();r++){
            if(strChunkRwRule.equals(arrayBibliotecaOrdresTortuga.get(r).toString())){
              arrayOrdresTortuga.add(strChunkRwRule);
              p=p+arrayBibliotecaOrdresTortuga.get(r).toString().length()-1;//Es calcula el salt que s'ha de fer quan s'ha acabat de llegir una ordre
              l=l+1;//Var. que posa les ordres llegides a l'arrayCadenaLlegida
            }
          }
      }
    }
    return arrayOrdresTortuga;
  }

  /*Loop que, una vegada llegit l'String de RwRule i guardat a l'array, crida al m?tode dibuixa
  per cada una de les ordres emmagatzemades. T? una particularitat: els par?mtres que se li envien
  a dibuixa() depenen de l'index de l'array amb les ordres tortuga. P.ex., si es la primera ordre,
  obviament no t? sentit enviar a dibuixa() l'ordre anterior; per aix? se li envia String buit o "" */
  public void gestionaDibuix(double dEscala){
    for (int m=0;m<arrayOrdresTortuga.size();m++){
      if(m==arrayOrdresTortuga.size()-1){
        dibuixa(arrayOrdresTortuga.get(m).toString(),"",arrayOrdresTortuga.get(m-1).toString(),dEscala,dCentreX,dCentreY);
      } else if (m==0){
          dibuixa(arrayOrdresTortuga.get(m).toString(),arrayOrdresTortuga.get(m+1).toString(),"",dEscala,dCentreX,dCentreY);
      } else {
          dibuixa(arrayOrdresTortuga.get(m).toString(),arrayOrdresTortuga.get(m+1).toString(),arrayOrdresTortuga.get(m-1).toString(),dEscala,dCentreX,dCentreY);
      }
    }
    //System.out.println("Rectes dibuixades: "+iConrRectDib);
    //System.out.println("Lletres dibuixades: "+iConrRectDib*5);
  }

  //M?tode DIBUIXA
  public void dibuixa(String strOrdreTortuga,String strOrdreTortugaMesU,String strOrdreTortugaMenysU,double dEscala,double dOX,double dOY){

    bFlagDuesIgualsInici=false;//Inicialitza el flag inici
    bFlagDuesIgualsFinal=false;//Inicialitza el flag final
    dCentreX=dOX;
    dCentreY=dOY;
    double dLongitud=dEscala;//Valor d'escala del fractal

    //Escull l'angle amb el que haur? de dibuixar la tortuga per una certa ordre
    if(strOrdreTortuga.equals("+F")){
      dAngle=dAngle+(Math.PI)/2;
    } else if(strOrdreTortuga.equals("-F")){
      dAngle=dAngle-(Math.PI)/2;
    } else if(strOrdreTortuga.equals("F")){
      dAngle=dAngle+0;
    }

    //Calcula les coordenades de destinaci?
    dNouCentreX=dLongitud*Math.cos(dAngle)+dCentreX;
    dNouCentreY=dLongitud*Math.sin(dAngle)+dCentreY;

    //Discerneix si hi han dues rectes consecutives amb igual direcci? i sentit
    if((strOrdreTortugaMenysU.equals("-F") && strOrdreTortuga.equals("-F") && strOrdreTortugaMesU.equals("F"))) bFlagDuesIgualsInici=true;
    if((strOrdreTortugaMenysU.equals("-F") && strOrdreTortuga.equals("F") && strOrdreTortugaMesU.equals("+F"))) bFlagDuesIgualsFinal=true;
    if((strOrdreTortugaMenysU.equals("+F") && strOrdreTortuga.equals("-F") && strOrdreTortugaMesU.equals("F"))) bFlagDuesIgualsInici=true;

    //Dibuixa les linies que composen el fractal (no es necess?ria)
    //g2d.draw(new Line2D.Double(dCentreX,dCentreY,dNouCentreX,dNouCentreY));

    //Escriu el text corresponent
    escriuRecta(dCentreX,dCentreY,dNouCentreX,dNouCentreY,strbTextTabulaSmaragdina.substring(iIniciText,iFinalText),bFlagDuesIgualsInici,bFlagDuesIgualsFinal);
    iIniciText=iFinalText;
    iFinalText=iFinalText+iNombreDivisions-2;
    if(iFinalText>strbTextTabulaSmaragdina.length()) {
      iIniciText=0;
      iFinalText=iNombreDivisions-2;
    }

    //Contador de rectes dibuixades
    iConrRectDib=iConrRectDib+1;

    //Canvi del punt de partida de la tortuga
    dCentreX=dNouCentreX;
    dCentreY=dNouCentreY;
  }

  //Escriu el text sobre la recta
  private void escriuRecta(double dX0,double dY0,double dX1,double dY1,String strTextTabulaSmaragdina,boolean bFlagDuesIgualsInici,boolean bFlagDuesIgualsFinal){

    //Construcci? del vector que defineix la recta
    double dX=dX1-dX0;
    double dY=dY1-dY0;

    //Classificaci? de la recta:
    //VU= Vertical UP (verical, en sentit cap amunt)
    //VD= Vertical Down (verical, en sentit cap abaix)
    //HR= Horitzontal Right (horitzontal, en sentit cap a la dreta)
    //HL= Horitzontal Left (horitzontal, en sentit cap a l'esquerra)
    /*Nota: s'ha de tenir en compte que el sistema de coordenades en el Panel
     ?s: 0 en la cantonada esquerra, amunt de tot. L'eix de les X es positiu des
     de l'origen cap a la dreta, i l'eix de les Y ?s positiu des de l'origen cap abaix.
     ?s a dir, la ?nica difer?ncia amb un sistema coordenat standard ?s que l'eix de les Y
     ?s positiu en sentit contr?ri*/
    
     //Correcció a 04/04/2006: els dX i dY que són extremadament petits, els iguala a 0.
     if((dX<0.0001 & dX>0) | (dX>-0.0001 & dX<0)) dX=0;
     if((dY<0.0001 & dY>0) | (dY>-0.0001 & dY<0)) dY=0;
    
     String strTipusRecta="";
     if(dX==0 && dY<0) strTipusRecta="VU";
     if(dX==0 && dY>0) strTipusRecta="VD";
     if(dX>0 && dY==0) strTipusRecta="HR";
     if(dX<0 && dY==0) strTipusRecta="HL";

     float fLongRecta=(float) Math.sqrt(dX*dX+dY*dY);  //C?lcul del m?dul del vector que defineix cada recta
     float fLongDivisioRectaBuida=fLongRecta/20; //literal arbitr?ri

     //Amplada d'una divisi? normal de tots els segments de recta (all? on s'hi ubicar? cada lletra 'q','o', etc.)
     float fLongDivisioRecta=0;
     if(bFlagDuesIgualsInici==false && bFlagDuesIgualsFinal==false){
       fLongDivisioRecta=(fLongRecta-2*fLongDivisioRectaBuida)/(iNombreDivisions-iNombreEspaisBuits);
     } else if (bFlagDuesIgualsInici==true || bFlagDuesIgualsFinal==true){
       fLongDivisioRecta=(2*fLongRecta-2*fLongDivisioRectaBuida)/(2*iNombreDivisions-2*iNombreEspaisBuits);
     }

     fAlturaLletra=7;//Parm?tere arbitr?ri (definida tamb? a PostProcess)

     int j=0;
     float Xlletra=0;
     float Ylletra=0;
 
     for(int i=0;i<iNombreDivisions;i++){
       if(i==0 || i==iNombreDivisions-1){ //Divisions n? 0 i 6
         if(bFlagDuesIgualsInici==true){
           if (strTipusRecta == "HR") {
             dX0 = dX0 + fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "HL") {
             dX0 = dX0 - fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "VD") {
             dY0 = dY0 + fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "VU") {
             dY0 = dY0 - fLongDivisioRectaBuida;
           }
         } else if (bFlagDuesIgualsFinal==true){
           if (strTipusRecta == "HR") {
             dX0 = dX0 ;
           }
           else if (strTipusRecta == "HL") {
             dX0 = dX0 ;
           }
           else if (strTipusRecta == "VD") {
             dY0 = dY0 ;
           }
           else if (strTipusRecta == "VU") {
             dY0 = dY0 ;
           }
         } else {

           if (strTipusRecta == "HR") {
             dX0 = dX0 + fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "HL") {
             dX0 = dX0 - fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "VD") {
             dY0 = dY0 + fLongDivisioRectaBuida;
           }
           else if (strTipusRecta == "VU") {
             dY0 = dY0 - fLongDivisioRectaBuida;
           }
         }
       }
       else if (i != 0 && i != iNombreDivisions - 1) { //Divisions de la n? 1 a la 5
    	 char cLletraTabulaSmaragdina=strTextTabulaSmaragdina.charAt(j);
         float fAmpladaLletra = (float) fm.charWidth(cLletraTabulaSmaragdina);
         
         if (strTipusRecta == "HR") {
           Xlletra = (float) dX0 + fLongDivisioRecta / 2 - fAmpladaLletra / 2;
           Ylletra = (float) dY0 + fAlturaLletra/2;
           dX0 = dX0 + fLongDivisioRecta;
         }
         else if (strTipusRecta == "HL") {
           Xlletra = (float) dX0 - fLongDivisioRecta / 2 - fAmpladaLletra / 2;
           Ylletra = (float) dY0 + fAlturaLletra/2;
           dX0 = dX0 - fLongDivisioRecta;
         }
         else if (strTipusRecta == "VD") {
           Xlletra = (float) dX0 - fAmpladaLletra / 2;
           Ylletra = (float) dY0 + fLongDivisioRecta / 2 + fAlturaLletra/2;
           dY0 = dY0 + fLongDivisioRecta;
         }
         else if (strTipusRecta == "VU") {
           Xlletra = (float) dX0 - fAmpladaLletra / 2;
           Ylletra = (float) dY0 - fLongDivisioRecta / 2 + fAlturaLletra/2;
           dY0 = dY0 - fLongDivisioRecta;
         }
         
         //Dibuixa cada lletra:
         g2d.drawString(Character.toString(cLletraTabulaSmaragdina), Xlletra, Ylletra);
         
         if(j<iNombreDivisions-iNombreEspaisBuits) j=j+1; else j=0;
       }
     }
  }

  //Dibuixa la iteració #0 (afegit 04/04/2006)
  public void dibuixaIter0(){
	  StringBuffer strbTextTabulaSmaragdinaSeparat1=new StringBuffer("QUOD EST INFERIUS EST SICUT QUOD EST SUPERIUS ET");
	  StringBuffer strbTextTabulaSmaragdinaSeparat2=new StringBuffer("QUOD EST SUPERIUS EST SICUT QUOD EST INFERIUS ET");
	  //Dibuixa primera frase: 
	  g2d.drawString(strbTextTabulaSmaragdinaSeparat1.toString(),(int)dCentreX,(int)dCentreY);
	  //Dibuixa segona frase:
	  int offset=0;
	  if (iFontSize==10) offset=15;
	  if (iFontSize==20) offset=28;
	  if (iFontSize==30) offset=45;
	  g2d.drawString(strbTextTabulaSmaragdinaSeparat2.toString(),(int)dCentreX,(int)dCentreY+offset);
  }
  
  /**
   * Carrega la biblioteca d'ordres possibles que pot entendre la tortuga 
   */
  private void carregaBibliotecaOrdresTortuga(){
    arrayBibliotecaOrdresTortuga.clear();
    //Definici? de l'array que cont? TOTES les ordres.
    arrayBibliotecaOrdresTortuga.add("F");
    arrayBibliotecaOrdresTortuga.add("+F");
    arrayBibliotecaOrdresTortuga.add("-F");
    iNumCaractMaxOrdres=2;//Nombre de caracters m?xims que pot contenir una ordre.
  }

  /**
   * Carrega la biblioteca d'operadors ("+","-", etc.) 
   */
  private void carregaBibliotecaOp(){
    arrayBibliotecaOp.clear();
    //Definici? de l'array que cont? TOTES les ordres.
    arrayBibliotecaOp.add("+");
    arrayBibliotecaOp.add("-");
  }

  /**
   * Getter del BufferedImage
   */
  public BufferedImage getBufferedImage(){
    return bi;
  }
  
  /**
   * Getter del nombre de lletres
   */
  public int getNumLletres(){
	  return iConrRectDib*5;
  }
  
  /**
   * Getter del nombre de rectes
   */
  public int getNumRectes(){
	  return iConrRectDib;
  }  
}