package grafica;

import java.awt.*;
import java.awt.geom.Rectangle2D;
import javax.swing.*;
import java.util.Vector;

/**
 * Clase que sirve para dibujar una grafica. Es importante fijarse que la clase 
 * tiene que extender JComponent para que podamos dibujar sobre ella.
 * 
 * @author Magus
 */
public class Board extends JComponent {
    
    Vector elements;
    /** 
     * COLORS_XXXX son un par de arreglos de colores para que aparezcan colores 
     * diferentes al dibujar 
     */
    final private Color COLORS_LIGHT[] = {
        new Color(255, 127 , 0),
        new Color(0, 255, 0),
        new Color(0, 192, 255),
        new Color(255, 255, 255),
        new Color(255, 255, 0),
        new Color(127, 0, 255)
    };
    
    final private Color COLORS_DARK[] = {
        new Color(127, 64 , 0),
        new Color(0, 127, 0),
        new Color(0, 96, 127),
        new Color(0, 0, 0),
        new Color(127, 127, 0),
        new Color(64, 0, 127)
    };
    
    /**
     * Crea un nuevo Board.
     */
    public Board() {
        elements = new Vector();
    }
    
    /**
     * Utiliza los datos del vector pasado como parametro para dibujar una 
     * grafica. El vector pasado como parametro debe contener valores numericos 
     * unicamente.
     * 
     * @param elements Vector que se va a utilizar para dibujar la grafica. El 
     *                 vector debe de tener puros valores numericos enteros
     */
    public void drawGraph(Vector elements) {
        this.elements = elements;
        repaint();
    }
    
    /** 
     * Metodo que nos permite pintar el componente.
     */
    public void paint(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        drawGraph(g2);
        g2.dispose();
    }
    
    /**
     * Este metodo pinta la grafica en el componente utilizando el objeto 
     * Graphics2D pasado como parametro. La grafica utiliza los valores que se 
     * encuentran en el vector de este objeto.
     * 
     * @param g2  Objeto que nos permite dibujar
     */
    public void drawGraph(Graphics2D g2) {
        int size = elements.size();
        int height = (int) this.getSize().getHeight();
        int width =  (int) this.getSize().getWidth();
        int barWidth = 0;
        if (size != 0) barWidth = (int) (width / size);
        
        /** Podemos poner el color igual que con Graphics */
        g2.setColor(new Color(0,255,0,127));
        /**
         * Podemos cambiar el tipo de linea que utiliza con el metodo 
         * setStroke(). El metodo setStroke() recibe un BasicStroke cuyo 
         * constructor unicamente es un valor float (por eso tiene que llevar 
         * una f al final porque no es double sino float) representando el ancho 
         * de linea.
         */
        g2.setStroke(new BasicStroke(5.0f));
        /** Podemos utilizar los mismos metodos que conocemos para dibujar */
        g2.fillOval(width - 100, 0, 80, 50);
        g2.setColor(Color.BLACK);
        g2.drawOval(width - 100, 0, 80, 50);
        g2.setFont(new Font("_Sans", Font.BOLD, 20));
        g2.drawString("Magus", width - 90, 35);
        
        for (int i = 0; i < size; i++) {
            
            Integer value = (Integer) elements.get(i);
            int xPos = (i * barWidth);
            
            Color color1 = COLORS_DARK [i % 6];
            Color color2 = COLORS_LIGHT[i % 6];
            
            /**
             * GradientPaint es un tipo de pintura con la que podemos dibujar 
             * cualquier figura. El constructor que utilizamos aqui recibe la 
             * posicion (x,y) donde empieza el degradado de color, el color de 
             * inicio, la posicion (x,y) donde termina el degradado de color y 
             * el color final. Despues podemos utilizar esta pintura para 
             * dibujar en la forma.
             */
            GradientPaint gradient = new GradientPaint(
                    xPos, height, color1, xPos, height - value, color2);
            /**
             * Con este metodo podemos elegir que pintura utiliza el Graphics2D 
             * para dibujar.
             * 
             * Para regresar a una pintura normal: 
             * g2.setPaint(Color.BLUE);
             */
            g2.setPaint(gradient);
            /** 
             * Para utilizar las pinturas solo podemos utilizar los metodos draw 
             * y fill de la clase Graphics2D, estos metodos reciben una figura y 
             * la pintan. Las figuras que puede recibir son entre otras:
             * 
             * Rectangle2D.Double(x, y, width, height)
             * Ellipse2D.Double(x, y, width, height)
             * RoundRectangle2D.Double(x, y, width, height, arcWidth, arcHeight)
             */
            g2.fill( new Rectangle2D.Double(xPos, height - value, barWidth, value) );
            
        }
    }
}