/*
 * Partida.java
 *
 * Created on 2 de junio de 2005, 15:43
 *
 * To change this template, choose Tools | Options and locate the template under
 * the Source Creation and Management node. Right-click the template and choose
 * Open. You can then make changes to the template in the Source Editor.
 */

package telefono;

import java.io.IOException;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

/**
 * representa los datos de una parida.
 * almacena los nombres de os jugadores y los puntos totales de cada jugador, en cada ronda.
 * los lpuntos parciales (los obtenidos en cada una de las rondas) son calculados.
 * @author Enrique Vicent Ramis
 * @version 1.0
 */
public class Partida
{
    public interface Reglas
    {
        public int getCartas(int ronda);
        public int[] getLines();
        public int decParcial();
        public int incParcial();
        public int decParcial(int parcial);
        public int incParcial(int parcial);
    }
    
    /**
     * constante que representa las reglas de pocheada
     */
    public static final int POCHEADA=1;
    /**
     * constante que representa las reglas de pocha normal
     */
    public static final int POCHA=2;
    /**
     * constante que representa las reglas genericas
     */
    public static final int OTRO=3;
    /** guardamos las normas en formato numero para poder almacenarlo en xml */
    private int idNormas;
    

    /**
     * lista ordenada por posiciones de los nombres de losjugadores
     */
    private String [] nombres;
    /**
     * estructura que almacena los puntos de la partida
     */
    private java.util.Vector /*Ronda*/ puntos;
    /**
     * constante indicativa de las reglas utilizadas
     */
    private int normas;
    /**
     * puntero a una clase de tipo reglas que contiene las reglas aplicadas a la partida en curso
     */
    private Reglas reglas;

    static final public String xmlTag = "partida";
    
    /**
     * obtiene  puntero a una clase de tipo reglas que contiene las reglas aplicadas a la partida en curso
     * @return  puntero a una clase de tipo reglas que contiene las reglas aplicadas a la partida en curso
     */
    Reglas getReglas()
    {
        return reglas;
    }
    
    /**
     * Creates a new instance of Partida
     * @param nombres lista de nombres de los jugadores. 
     * Esta variable tambien se emplear? para calcular el n?mero
     * de jugadores de la parida
     * @param tipo constante indicativa de las reglas que se emplear?n en
     * la partida
     * @see POCHEADA
     * @see POCHA
     * @see OTRO
     */
    public Partida(String [] nombres, int tipo) 
    {
        setNombres(nombres);
        setNormas(tipo);
        idNormas=tipo;
        puntos=new java.util.Vector();
    }
    
    /**
     * constructor, basado en xml
     */
    public Partida(java.io.Reader xml, XmlPullParser analizador) throws XmlPullParserException, IOException
    {
        boolean finPartidaEncontrado=false;
        puntos=new java.util.Vector();
        java.util.Vector jugadores=new java.util.Vector();
        int tag;
        int ronda=0;
        int jugador=0;
        while(finPartidaEncontrado==false)
        {
            tag=analizador.nextTag();
            if(tag==analizador.END_TAG)
                finPartidaEncontrado=analizador.getName().equals(xmlTag);
            else if(tag==analizador.START_TAG)
            {
                //captura de los jutadores;
                //se requiere que los gugadores vayan antes que los puntos
                if(analizador.getName().equals("jugador"))
                {
                    while(tag!=analizador.TEXT)
                        tag=analizador.nextToken();//saltar comentarios
                    String nombre=analizador.getText();
                    jugadores.addElement(nombre);
                    analizador.nextTag();//tag de cierre        
                    //finalizada la lectura componemos ls datos
                    String[] nom=new String[jugadores.size()];
                    jugadores.copyInto(nom);
                    setNombres(nom);
                }
                //procesamos los puntos
                //importante todos los nombres deben estar ya definidos
                else if(analizador.getName().equals("puntos"))
                {
                    ronda++;
                    jugador=0;
                    boolean tagSalidaPuntos=false;
                    while (tagSalidaPuntos==false)
                    {                        
                        tag=analizador.nextTag();
                        if(tag==analizador.END_TAG)
                        {
                            if(analizador.getName().equals("puntos"))
                                tagSalidaPuntos=true;
                        }
                        else if(tag==analizador.START_TAG)
                        {
                            String nombre=analizador.getName();
                            if(nombre.equals("punto"))
                            {
                                jugador++;
                                while(tag!=analizador.TEXT)
                                    tag=analizador.nextToken();//saltar comentarios
                                String spunto=analizador.getText();
                                try
                                {
                                    int punto=Integer.parseInt(spunto);
                                    setParcial(jugador,ronda,punto);
                                }
                                catch (Exception e)
                                {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
                //establecemos las reglas
                else if(analizador.getName().equals("reglas"))
                {
                    while(tag!=analizador.TEXT)
                        tag=analizador.nextToken();//saltar comentarios
                    String snorma=analizador.getText();
                    try
                    {
                        int norma=Integer.parseInt(snorma);
                        setNormas(norma);
                    }
                    catch (Exception e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * obtiene la lista de nombres de los jugadores
     * @return lista de nombres de los jugadores
     */
    public String[] getNombres() 
    {
        return nombres;
    }

    /**
     * atenci?n modificar los nombres a mitad de partida puede dar 
     * resltados imprevistos si se modifica el n?mero de los mismos
     * @param nombres nombres de los jugadores
     */
    public void setNombres(String[] nombres) 
    {
        this.nombres = nombres;
    }

    /**
     * obtiene una estructura con los puntos de la partida
     * @return estructura con los puntos de la partida
     */
    public java.util.Vector getPuntos() 
    {
        return puntos;
    }

    /**
     * setter de puntos
     * @deprecated no es conveniente establecer los puntos por este mecanismo. este es un setter convencional. no realiza comprobaci?n ninguna de la coherencia de los datos
     * @param puntos estructura de puntos
     */
    public void setPuntos(java.util.Vector puntos) 
    {
        this.puntos = puntos;
    }

    /**
     * getter de normas
     * @return obtiene la constante indicativa de las reglas empleadas
     */
    public int getNormas() 
    {
        return normas;
    }

    /**
     * setter de la constant indicativa de las normas
     * @param normas constante inicativa de las norms
     */
    public void setNormas(int normas) 
    {
        this.normas = (normas>0 && normas<4)?normas:OTRO;
        switch(normas)
        {
            case POCHA:
                reglas=new telefono.reglas.Pocha(getNJugadores());
                break;
            case POCHEADA:
                reglas=new telefono.reglas.Pocheada(getNJugadores());
                break;
            case OTRO:
            default:
                reglas=new telefono.reglas.Otro();
                break;
        }
    }

    /**
     * establece un valor de puntos acumulados
     * @param jugador jugador a la que se le asignan los puntos
     * @param ronda ronda en que se le asigna los puntos
     * @param valor puntos totales para el ugador y la ronda
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.
     */
    public void setAcumulado(int jugador, int ronda, int valor)throws IndexOutOfBoundsException
    {
        if(ronda>getRondas()+1 || ronda<=0)
            throw new IndexOutOfBoundsException();
        if(ronda<getRondas(jugador))
        {
            try
            {
                //no es la ?ltima ronda
                int sig=this.getAcumulado(jugador, ronda+1);
                int esta=this.getAcumulado(jugador,ronda);
                this.setAcumulado(jugador, ronda+1,sig-esta+valor);
            }
            catch(IndexOutOfBoundsException ioobe)
            {
                //nada, si no se puede no se puede. sin traumas
            }
        }
        if(puntos.size()==ronda-1)
        {
            getAcumulado(jugador,ronda-1);//probamos que tiene una anotaci?n anterior o es el primer
            puntos.addElement(new Ronda(getNJugadores(),reglas.getCartas(ronda),1));
        }
        ((Ronda)(puntos.elementAt(ronda-1))).setPuntos(jugador, valor);
    }
    
    /**
     * calcula el n?mero de jugadores de la parida en funci?n del n?mero de nombres de 
     * jugador establecidos.
     * @return numero de jugadores
     */
    public int getNJugadores()
    {
        return nombres.length;
    }

    /**
     * obtiene un valor acumulado