package database.multidim.affichage.ecran;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.font.*;
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;

import database.multidim.affichage.Cellule;
import database.multidim.affichage.Valeur;


import java.util.ArrayList;

/**
 * Permet l'affichage des données envoyées
 * @author Renan
 *
 */
public class Ecran extends JFrame implements WindowListener,AdjustmentListener {
        Font f_1  = new Font("Serif", Font.PLAIN,10);//servent pour les styles de cases
        Font f_2  = new Font("Serif", Font.BOLD,10);

        JScrollBar slider3=new JScrollBar();//vont être supprimées
        JScrollBar slider4=new JScrollBar(0);//
       
        JScrollPane panell;          // le panneau central, sur lequel sera mis le JPanel qui contient les cases
        JScrollPane paneAxeHaut;// le panneau du haut, sur lequel sera mis le JPanel qui contient les axes
        JScrollPane paneAxeGauche; // le panneau du bas, surlequel sera mis le JPanel qui contient les axes

        JPanel paneangle = new JPanel();//L'angle en haut à gauche
        JPanel paneHaut = new JPanel();//l'axe du haut
        JPanel paneGauche = new JPanel();//l'axe sur la gauche

        JPanel paneAjout = new JPanel();//le JPanel sur lequel on dessine les cases.
               
        //les gestionnaires et leurs contraintes
        GridBagLayout gbl = new GridBagLayout();
        GridBagConstraints gbc = new GridBagConstraints();
        GridBagLayout gblHaut = new GridBagLayout();
        GridBagConstraints gbcHaut = new GridBagConstraints();
        GridBagLayout gblGauche = new GridBagLayout();
        GridBagConstraints gbcGauche = new GridBagConstraints();
       
        int tailleCase, cpt, nbTot, axeTotH, axeTotG;
        //tailleCase est la variable qui sert à calculer la taille des cases et leur position
        //cpt est un compteur
        //nbTot est un majorant du nombre de faits.
        //axeTotH est celui du nombre de cellules en haut
        //axeTotG, celui pour l'axe à gauche
       
        Case[] tabCentres;// c'est l'ensemble des cases à afficher
        Case[] tabHauts;// c'est l'ensemble des axes du haut à afficher
        Case[] tabGauches;// C'est l'ensemble des axes de gauche à afficher

       
        int axeHautX,axeHautY;
        //les coordonées des cases sur l'axe du haut
        int axeGaucheX,axeGaucheY;
        //les coordonées des cases sur l'axe de gauche
       
       
        ArrayList[] axis = new ArrayList[2];
        //les axes
        ArrayList temp = new ArrayList();
       
        Valeurs[] cT;
        Valeurs vall = new Valeurs();
        Cellule cell = new Cellule();
        /**
         * Constructeur de base. Il s'agit d'initialiser les variables et la fenêtre.
         *
         */
        public Ecran(ArrayList[] a,Valeur[][] vale) {
                super("Projet M1");
                int i,j;
                cpt = 0;
                axis[0] = new ArrayList();
                axis[1] = new ArrayList();
        for(i=0;i<vale.length;i++){
                for(j=0;j<vale[i].length;j++){
                        if(vale[i][j]!=null){
                                cpt++; 
                        }
                }
        }
        cT = new Valeurs[cpt];
        tabHauts = new Case[cpt];
        tabGauches = new Case[cpt];
        for(i=0;i<cpt;i++) {
                cT[i] = new Valeurs();
        }
        cpt = -1;
        for(i=0;i<vale.length;i++){
                for(j=0;j<vale[i].length;j++){
                        if(vale[i][j]!=null){
                                cpt++;
                                cT[cpt].coordonnees = vale[i][j].coordonnees;
                                cT[cpt].donnee = vale[i][j].donnee;
                                cT[cpt].style = vale[i][j].style;
                                cT[cpt].taille = vale[i][j].taille;
                                cT[cpt].x = i;
                                cT[cpt].y = j;
                        }
                }
        }
        tailleCase = 50;
        nbTot = cpt+1;
        axeTotH = cpt+1;
        axeTotG = cpt+1;
        tabCentres = new Case[nbTot];
        axeHautX=1;
        axeHautY=1;
        axeGaucheX=1;
        axeGaucheY=1;
        axis = a;
        this.creerInterface();

        super.pack();
        super.setVisible(true);
       
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
       
        /**
         * Le véritable moteur d'affichage. Il s'agit d'installer chacun des éléments graphiques.
         *
         */
    public void creerInterface() {
        int a,b;//compteurs pour mettre les axes.
       
        //installation des gestionnaires.     
        paneAjout.setLayout(gbl);
        paneHaut.setLayout(gblHaut);
        paneGauche.setLayout(gblGauche);
       
        //Pour chacun des faits on :
        for(cpt = 0; cpt<nbTot;cpt++){
                tabCentres[cpt] = new Case(cT[cpt].donnee,cT[cpt].coordonnees,cT[cpt].style);
                //crée une Case
                gbc = paneAff(tabCentres[cpt],cT[cpt]);
                //on crée les contraintes
                tabCentres[cpt] = choixStyle(cT[cpt].style, tabCentres[cpt]);
                //le choix du style d'écriture et du fond de la case
                paneAjout.add(tabCentres[cpt], gbc);
                //On ajoute la Case sur le JPanel fait pour.
        }
       
        cpt = -1;
        for(a = 0; a<axis[0].size();a++){
                temp=(ArrayList)axis[0].get(a);
                axeHautX = 1;
                axeHautY = a+1;
                for(b=0;b<temp.size();b++){
                        cpt++;
                        tabHauts[cpt] = new Case(((Cellule)temp.get(b)).donnee," ",((Cellule)temp.get(b)).style);
                        //crée une Case
                        vall.coordonnees = " ";
                        cell = (Cellule)temp.get(b);
                        vall.donnee = cell.donnee;
                        vall.style = cell.style;
                        vall.taille[0] = (int)cell.taille[0];
                        vall.taille[1] = (int)cell.taille[1];
                        vall.x = axeHautX;
                        vall.y = axeHautY;
                        System.out.print("axe du haut : "+a+" ");
                        gbcHaut = paneAff(tabHauts[cpt],vall);
                        //on crée les contraintes

                axeHautX = axeHautX + vall.taille[0];
                        tabHauts[cpt] = choixStyle(((Cellule)temp.get(b)).style,tabHauts[cpt]);
                        //le choix du style d'écriture et du fond de la case
                        paneHaut.add(tabHauts[cpt], gbcHaut);
                        //On ajoute la Case sur le JPanel fait pour.
                }
        }
        cpt = -1;
        for(a = 0; a<axis[1].size();a++){
                temp=(ArrayList)axis[1].get(a);
                axeGaucheY = 1;
                axeGaucheX= a+1;
                for(b=0;b<temp.size();b++){
                        cpt++;
                        tabGauches[cpt] = new Case(((Cellule)temp.get(b)).donnee," ",((Cellule)temp.get(b)).style);
                        //crée une Case
   
                        vall.coordonnees = " ";
                        cell = (Cellule)temp.get(b);
                        vall.donnee = cell.donnee;
                        vall.style = cell.style;
                        vall.taille[0] = (int)cell.taille[0];
                        vall.taille[1] = (int)cell.taille[1];
                        vall.x = axeGaucheX;
                        vall.y = axeGaucheY;
                        System.out.print("Voilà : ");
                        gbcGauche = paneAff(tabGauches[cpt],vall);
                        //on crée les contraintes

                axeGaucheY = axeGaucheY + vall.taille[1];               
                        //gbcGauche = paneAff(tabGauches[cpt],vall);
                        //on crée les contraintes
                        tabGauches[cpt] = choixStyle(((Cellule)temp.get(b)).style,tabGauches[cpt]);
                        //le choix du style d'écriture et du fond de la case
                        paneGauche.add(tabGauches[cpt], gbcGauche);
                        //On ajoute la Case sur le JPanel fait pour.
                }
        }
        panell = new JScrollPane(paneAjout);
        //On met le JPanel qui contient les cases dans un JScrollPane afin d'avoir
        //des JScrollBar quand c'est nécessaire
        paneAxeHaut = new JScrollPane(paneHaut);
        paneAxeGauche = new JScrollPane(paneGauche);
       
        paneAxeGauche.getHorizontalScrollBar().addAdjustmentListener(this);
        paneAxeHaut.getHorizontalScrollBar().addAdjustmentListener(this);
        panell.getHorizontalScrollBar().addAdjustmentListener(this);
        panell.getVerticalScrollBar().addAdjustmentListener(this);
        //Ici on indique que les scrollbar réagissent à certains évennements

       
        JPanel pan = (JPanel)this.getContentPane();       
        BorderLayout gestionnaire = new BorderLayout();
        pan.setLayout(gestionnaire);
        pan.add(panell, BorderLayout.CENTER);
        pan.add(paneAxeHaut, BorderLayout.NORTH);
        pan.add(paneAxeGauche, BorderLayout.WEST);
        //Ici on place toutes les différents panneaux dans la fenêtre.
    }
    /**
     * Permet d'installer les Valeur sur les Cases
     * @param sousComposant : correspond à la case pour lequel on veut connaître les contraintes.
     * @param val : la Valeur à appliquer à la contrainte.
     * @return : retourne un GridBagConstraints pour le gestionnaire GridBagLayout
     */
    public GridBagConstraints paneAff(Component sousComposant, Valeurs val){
        int gX,gY,gH,gW;//Les variables temporaires
        gX = val.x*tailleCase;
        gY = val.y*tailleCase;
        //Positionnement
        gH = val.taille[0]*tailleCase;
        gW = val.taille[1]*tailleCase;

        sousComposant.setPreferredSize(new Dimension((int)gH,(int)gW));
        //Taille
       
        GridBagConstraints contraintes= new GridBagConstraints();
        contraintes.fill= GridBagConstraints.NONE;
        contraintes.gridx = gX;
        contraintes.gridy = gY;
        contraintes.gridwidth = gW;
        contraintes.gridheight = gH;
        contraintes.anchor = GridBagConstraints.NORTHWEST;
        //Les différentes contraintes de la Case
        System.out.println(gX+" "+gY+" "+val.x+" "+val.y);
        return contraintes;
        
     }

   
    /**
     * Permet de choisir le type de case (couleur et police)
     * @param choix : le style choisi
     * @return un Axes modifié
     */
    public Case choixStyle(int choix, Case tab){
        //choix font et background   
        switch(choix){
        case -1 : tab.setBackground(Color.WHITE);
                  tab.setFont(f_1);
                  break;
        case 0 : tab.setBackground(Color.WHITE);
                 tab.setFont(f_1);
                 break;
        case 1 : tab.setBackground(Color.WHITE);
                 tab.setFont(f_2);
                 break;
        case 2 : tab.setBackground(Color.CYAN);
                 tab.setFont(f_1);
                 break;
        case 3 : tab.setBackground(Color.CYAN);
                 tab.setFont(f_2);
                               break;
        default : tab.setBackground(Color.BLACK);
                  tab.setFont(f_2);
                  break;
       
        }
        return tab;
    }
   
    /**
     * Décrit ce qui se passe quand la valeur des scrollbar change.
     * Ici il s'agit de lier les scrollbar des axes et des cases.
     */
        public void adjustmentValueChanged(AdjustmentEvent e){
                JScrollBar sb = (JScrollBar) e.getSource();
                if(sb == panell.getHorizontalScrollBar()){
                        paneAxeHaut.getHorizontalScrollBar().setValue(panell.getHorizontalScrollBar().getValue()*100/paneAxeHaut.getHorizontalScrollBar().getMaximum());
                }
                if(sb == paneAxeHaut.getHorizontalScrollBar()){
                        panell.getHorizontalScrollBar().setValue((paneAxeHaut.getHorizontalScrollBar().getValue()/**100*/)/*/panell.getHorizontalScrollBar().getMaximum()*/);
                }              
                if(sb == panell.getVerticalScrollBar()){
                        paneAxeGauche.getHorizontalScrollBar().setValue((panell.getVerticalScrollBar().getValue()*100)/paneAxeGauche.getHorizontalScrollBar().getMaximum());
                }
                if(sb == paneAxeGauche.getHorizontalScrollBar()){
                        panell.getVerticalScrollBar().setValue(paneAxeGauche.getHorizontalScrollBar().getValue());
                }       
        }

   
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowActivated(WindowEvent e)  {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowDeactivated(WindowEvent e)  {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowOpened(WindowEvent e)  {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowIconified(WindowEvent e)  {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowDeiconified(WindowEvent e) {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowClosed(WindowEvent e) {}
    /**
     * Méthode par défaut due aux Implements
     */
        public void windowClosing(WindowEvent e){
                System.exit(0); 
        }
       
       
}

package database.multidim.affichage.ecran;
import javax.swing.*;
import java.awt.*;
/**
 * Les cases des faits
 * @author Renan
 *
 */
public class Case extends JPanel{
        String texte,coord;
        int style;

        /**
         * récupère deux strings
         * @param s : le premier string à mettre en constructeur (obligatoire), les données
         * @param d : le second string à mettre en constructeur (obligatoire), les coordonnées
         * @param i : le style d'écriture à mettre en constructeur (obligatoire), la couleur
         */
        public Case(String s, String d, int i){
                texte = s;
                coord = d;
                style = i;
        }
        /**
         * Dessine les textes sur la case
         */
        public void paintComponent(Graphics g){
                super.paintComponent(g);
                switch(style) {
                case -1 : g.setColor(Color.GRAY);
                                break;
                case 0 :
                case 1 :
                case 2 :
                case 3 :g.setColor(Color.BLACK);
                                break;
                default :g.setColor(Color.WHITE);
                                break;
                }
                g.drawString(texte,10,10);
                g.drawString(coord,10,25);
               
        }
}

package database.multidim.affichage;

public class Cellule {
        public String donnee="";
        public int style=0;
        public float[] taille=new float[2];
}

package database.multidim.affichage;

public class Valeur {
        public String donnee="";
        public String coordonnees="";
        public int style=0;
        public int[] taille=new int[2];
}