package javabbuva;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.Observable; //MVC PARA VIGILAR EL CAMBIO DE SALDO




// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.54FE565A-ADFF-29FB-B0B8-6AFFF138BA57]
// </editor-fold> 
public class Sucursal extends Observable{

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.75ED3106-CB74-11DE-CEDD-6D68E4706CB9]
    // </editor-fold> 
    private List <Producto> mProducto;

    private List <PardeDiferencia> mPartes;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.E9FE3625-E5E5-6996-4B10-01B154257601]
    // </editor-fold> 
    private List <Caja> mCaja;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.615C0B10-F549-DB92-6C9F-331E5EE7EC43]
    // </editor-fold> 
    private List <Empleado> mEmpleado;

    private List <ClienteFisico> mClientesF;

    private List <ClienteJuridico> mClientesJ;

    private List <Remesa> mRemesas;

    private Caja cajaActual;

    private Empleado empleadoActual;

    private Entidad entidad;

    private String mensajeError; //para las remesas

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.88BB6353-0C1F-33DE-3F74-B44FC56EBD5B]
    // </editor-fold> 
    public Sucursal () {
        mProducto = new ArrayList();
        mRemesas = new ArrayList();
        mCaja = new ArrayList();
        mEmpleado = new ArrayList();
        mClientesF = new ArrayList();
        mClientesJ = new ArrayList();
        cajaActual = new Caja();
        entidad = new Entidad();
        mPartes = new ArrayList();
        empleadoActual = new Empleado();
        mensajeError = "";
    }

    //**************************************
    //AÑADIR CLIENTES Y PRODUCTOS
    //**************************************

    //DICE SI UN CLIENTE FISICO EXISTE O NO
    public boolean existeClienteF(String DNI){
        int i = 0;
        while(i < mClientesF.size()){
            if(mClientesF.get(i).getDNI().equals(DNI)){
                return true;
            }
            else
                i++;
        }
        return false;
    }

    //DICE SI UN CLIENTE JURIDICO EXISTE O NO
    public boolean existeClienteJ(String NIF){
        int i = 0;
        while(i < mClientesJ.size()){
            if(mClientesJ.get(i).getNIF().equals(NIF)){
                return true;
            }
            else
                i++;
        }
        return false;
    }

    //DEVUELVE UN CLIENTE FISICO POR SU DNI
    public ClienteFisico dameClienteF(String DNI){
        ClienteFisico aux = new ClienteFisico();
        int i = 0;
        while(i < mClientesF.size()){
            if(mClientesF.get(i).getDNI().equals(DNI)){
                aux = mClientesF.get(i);
                i = mClientesF.size();
            }
            else
                i++;
        }
        return aux;
    }

    //DEVUELVE UN CLIENTE JURIDICO POR SU DNI
    public ClienteJuridico dameClienteJ(String NIF){
        ClienteJuridico aux = new ClienteJuridico();
        int i = 0;
        while(i < mClientesJ.size()){
            if(mClientesJ.get(i).getNIF().equals(NIF)){
                aux = mClientesJ.get(i);
                i = mClientesJ.size();
            }
            else
                i++;
        }
        return aux;
    }

    //CREAMOS UN PRODUCTO A UN CLIENTE FISICO
    public void crearProductoF(String nombre, String apellido1, String apellido2, String DNI, String telefono, String direccion, String tipo, float saldo){
        //SI EL CLIENTE YA EXISTE
        if(existeClienteF(DNI)){
            ClienteFisico c = dameClienteF(DNI);

            Producto p = new Producto();
            p.setDinero(saldo);
            p.setTipo(tipo);
            p.incrementarTitulares();

            p.añadirCliente(c);
            c.añadirProducto(p);

            if(mProducto.size() == 0){
                p.setNumeroCuenta("20984002161000000001");
            }
            else{
                //COJEMOS LA ULTIMA CUENTA EN DOS PARTES E INCREMENTAMOS
                String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
                String izquierda;
                int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
                if(derecha<10)
                    izquierda = ultimaCuenta.substring(0, 19);
                else if(derecha<100)
                    izquierda = ultimaCuenta.substring(0, 18);
                else
                    izquierda = ultimaCuenta.substring(0, 17);
                p.setNumeroCuenta(izquierda+String.valueOf(derecha));
            }
            añadirProducto(p);
        }
        else{
            ClienteFisico cf = new ClienteFisico();
            cf.setNombre(nombre);
            cf.setDNI(DNI);
            cf.setTelefono(telefono);
            cf.setApellido1(apellido1);
            cf.setApellido2(apellido2);
            cf.setDireccion(direccion);

            Producto p = new Producto();
            p.setDinero(saldo);
            p.setTipo(tipo);
            p.incrementarTitulares();

            if(mProducto.size() == 0){
                p.setNumeroCuenta("20984002161000000001");
            }
            else{
                String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
                String izquierda;
                int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
                if(derecha<10)
                    izquierda = ultimaCuenta.substring(0, 19);
                else if(derecha<100)
                    izquierda = ultimaCuenta.substring(0, 18);
                else
                    izquierda = ultimaCuenta.substring(0, 17);
                p.setNumeroCuenta(izquierda+String.valueOf(derecha));
            }

            p.añadirCliente(cf);
            cf.añadirProducto(p);
            añadirClienteF(cf);
            añadirProducto(p);
        }
        getCajaActual().incrementarSaldo(saldo);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //AÑADIMOS UN NUEVO TITULAR AL PRODUCTO
    public void añadirTitular(String nombre, String apellido1, String apellido2, String DNI, String telefono, String direccion, String DNIprincipal){
        //SI EL CLIENTE YA EXISTE
            if(existeClienteF(DNI)){
                ClienteFisico cli = dameClienteF(DNI);
                Producto p = ultimoAñadido();
                p.añadirCliente(cli);
                p.incrementarTitulares();
                cli.añadirProducto(p);
            }
            //SI NO EXISTE
            else{
                ClienteFisico cli = new ClienteFisico();
                cli.setNombre(nombre);
                cli.setApellido1(apellido1);
                cli.setApellido2(apellido2);
                cli.setDNI(DNI);
                cli.setDireccion(direccion);
                cli.setTelefono(telefono);

                Producto p = ultimoAñadido();
                p.añadirCliente(cli);
                p.incrementarTitulares();
                cli.añadirProducto(p);

                añadirClienteF(cli);
            }
    }

    //CREAMOS UN PRODUCTO A UN CLIENTE JURIDICO
    public void crearProductoJ(String nombre, String NIF, String telefono, String direccion, String tipo, float saldo){
        //SI EL CLIENTE YA EXISTE NO LO AÑADIMOS OTRA VEZ
        if(existeClienteJ(NIF)){
            ClienteJuridico c = dameClienteJ(NIF);

            Producto p = new Producto();
            p.setDinero(saldo);
            p.setTipo(tipo);
            p.incrementarTitulares();

            p.añadirCliente(c);
            c.añadirProducto(p);

            if(mProducto.size() == 0){
                p.setNumeroCuenta("20984002161000000001");
            }
            else{
                String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
                String izquierda;
                int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
                if(derecha<10)
                    izquierda = ultimaCuenta.substring(0, 19);
                else if(derecha<100)
                    izquierda = ultimaCuenta.substring(0, 18);
                else
                    izquierda = ultimaCuenta.substring(0, 17);
                p.setNumeroCuenta(izquierda+String.valueOf(derecha));
            }
            añadirProducto(p);
        }
        else{
            ClienteJuridico cj = new ClienteJuridico();
            cj.setNombre(nombre);
            cj.setNIF(NIF);
            cj.setTelefono(telefono);
            cj.setDireccion(direccion);

            Producto p = new Producto();
            p.setDinero(saldo);
            p.setTipo(tipo);
            p.incrementarTitulares();

            p.añadirCliente(cj);
            cj.añadirProducto(p);

            if(mProducto.size() == 0){
                p.setNumeroCuenta("20984002161000000001");
            }
            else{
                String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
                String izquierda;
                int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
                if(derecha<10)
                    izquierda = ultimaCuenta.substring(0, 19);
                else if(derecha<100)
                    izquierda = ultimaCuenta.substring(0, 18);
                else
                    izquierda = ultimaCuenta.substring(0, 17);
                p.setNumeroCuenta(izquierda+String.valueOf(derecha));
            }
            añadirClienteJ(cj);
            añadirProducto(p);
        }
        getCajaActual().incrementarSaldo(saldo);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //DEVUELVE EL ULTIMO PRODUCTO AÑADIDO PARA SABER EL NUMERO DE CUENTA DESPUES
    public Producto ultimoAñadido(){
        Producto aux = mProducto.get(mProducto.size()-1);
        return aux;
    }

    //COMPRUEBA LA COINCIDENCIA ENTRE UN DNI Y UNA CUENTA
    public boolean comprobarCoincidenciaF(String DNI, String cuenta){
        if(existeClienteF(DNI)){
            ClienteFisico c = new ClienteFisico();
            c = dameClienteF(DNI);
            if(c.existeCuenta(cuenta))
                return true;
            else return false;
        }
        else
            return false;
    }
    
    //COMPRUEBA LA COINCIDENCIA ENTRE UN NIF Y UNA CUENTA
    public boolean comprobarCoincidenciaJ(String NIF, String cuenta){
        if(existeClienteJ(NIF)){
            ClienteJuridico c = new ClienteJuridico();
            c = dameClienteJ(NIF);
            if(c.existeCuenta(cuenta)) 
                return true;
            else return false;
        }
        else
            return false;
    }

    //CREAMOS UN PRESTAMO PARA UN CLIENTE FISICO
    public void crearPrestamoF(String DNI, String cuenta, float cantidad, String tipo){
        Cliente c = dameClienteF(DNI);
        Producto p;
        if(tipo.compareTo("Pestamo Personal")==0){
            p = new PrestamoPersonal();
        }
        else{
            p = new PrestamoHipotecario();
        }
        p.setDinero(cantidad);
        p.setTipo(tipo);
        p.setCuentaAsociada(cuenta);

        //COJEMOS LA ULTIMA CUENTA EN DOS PARTES E INCREMENTAMOS
        String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
        String izquierda;
        int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
        if(derecha<10)
             izquierda = ultimaCuenta.substring(0, 19);
        else if(derecha<100)
             izquierda = ultimaCuenta.substring(0, 18);
        else
             izquierda = ultimaCuenta.substring(0, 17);
        p.setNumeroCuenta(izquierda+String.valueOf(derecha));

        //p.setNumeroCuenta(String.valueOf(Integer.parseInt(ultimoAñadido().getNumeroCuenta())+1));
        p.incrementarTitulares();
        
        p.añadirCliente(c);
        c.añadirProducto(p);
        
        mProducto.add(p);
    }
    
    //CREAMOS UN PRESTAMO PARA UN CLIENTE JURIDICO
    public void crearPrestamoJ(String NIF, String cuenta, float cantidad, String tipo){
        Cliente c = dameClienteJ(NIF);

        PrestamoPersonal p = new PrestamoPersonal();

        p.setDinero(cantidad);
        p.setTipo(tipo);
        p.setCuentaAsociada(cuenta);
        //p.setNumeroCuenta(String.valueOf(Integer.parseInt(ultimoAñadido().getNumeroCuenta())+1));

        //COJEMOS LA ULTIMA CUENTA EN DOS PARTES E INCREMENTAMOS
        String ultimaCuenta = ultimoAñadido().getNumeroCuenta();
        String izquierda;
        int derecha = Integer.parseInt(ultimaCuenta.substring(17,20))+1;
        if(derecha<10)
            izquierda = ultimaCuenta.substring(0, 19);
        else if(derecha<100)
            izquierda = ultimaCuenta.substring(0, 18);
        else
            izquierda = ultimaCuenta.substring(0, 17);
        p.setNumeroCuenta(izquierda+String.valueOf(derecha));

        p.incrementarTitulares();

        p.añadirCliente(c);
        c.añadirProducto(p);

        mProducto.add(p);
    }

    //AÑADIMOS UN CLIENTE FISICO
    public void añadirClienteF(ClienteFisico cli) {
        mClientesF.add(cli);
    }

    //AÑADIMOS UN CLIENTE JURIDICO
    public void añadirClienteJ(ClienteJuridico cli) {
        mClientesJ.add(cli);
    }

    //DEVUELVE LOS PRODUCTOS DE UN CLIENTE FISICO BUSCANDO POR SU DNI
    public List<Producto> getProductoClienteF(String nombre, String DNI) {
        int indice=-1;
        List <Producto> aux = new ArrayList();
        int i = 0;
        while(i < mClientesF.size()){
            if(mClientesF.get(i).getDNI().equals(DNI)){
                indice = i;
                i = mClientesF.size();
            }
            else
                i++;
        }
        if(indice != -1){
        aux = mClientesF.get(indice).getMProductos();
        }
        return aux;
    }

    //DEVUELVE LOS PRODUCTOS DE UN CLIENTE JURIDICO BUSCANDO POR SU NIF
    public List<Producto> getProductoClienteJ(String nombre, String NIF) {
        int indice=-1;
        List <Producto> aux = new ArrayList();
        int i = 0;
        while(i < mClientesJ.size()){
            if(mClientesJ.get(i).getNIF().equals(NIF)){
                indice = i;
                i = mClientesJ.size();
            }
            else
                i++;
        }
        if(indice != -1){
        aux = mClientesJ.get(indice).getMProductos();
        }
        return aux;
    }

    //****************************************
    //**** REALIZAR INGRESOS Y REINTEGROS ****
    //****************************************

    //DEVUELVE UN PRODUCTO POR SU NUMERO DE CUENTA
    public Producto dameCuenta(String numero){
        Producto aux = new Producto();
        int i= 0;
        while(i<mProducto.size()){
            if(mProducto.get(i).getNumeroCuenta().compareTo(numero)==0){
                aux = mProducto.get(i);
                i = mProducto.size();
            }
            else
                i++;
        }
        return aux;
    }

    //AÑADE DINERO A LA CAJA ACTUAL
    public void añadirDinero(float i){
        cajaActual.incrementarSaldo(i);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //RESTA DINERO A LA CAJA ACTUAL
    public void restarDinero(float i){
        cajaActual.decrementarSaldo(i);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //METODO QUE COJE DINERO DE LA CAJA CENTRAL Y LO TRAE A LA ACTUAL
    public void traerDinero(float cantidad) {
        cajaActual.incrementarSaldo(cantidad);
        entidad.getCajacentral().decrementarSaldo(cantidad);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //METODO QUE ENVIA DINERO A LA CAJA CENTRAL
    public void enviarCentral(float cantidad) {
        entidad.añadirDinero(cantidad);
        cajaActual.decrementarSaldo(cantidad);
        setChanged();
        notifyObservers(getCajaActual().getSaldo());
    }

    //***********************************
    //******* MOVIMIENTOS ***************
    //***********************************

    //CREAR MOVIMIENTO A UN PRODUCTO
    public void crearMovimiento(Producto p, float dinero, String concepto){
        Movimientos m = new Movimientos();
        m.setProducto(p);
        m.setConcepto(concepto);
        m.setDinero(dinero);

        p.incluirMovimiento(m);
    }

    //DEVUELVE UN MOVIMIENTO DE UN PRODUCTO DADO SU IDENTIFICADOR Y EL NUMERO DE CUENTA DEL PRODUCTO
    public Movimientos dameMovimiento(String a, String a2){
        Movimientos aux = new Movimientos();
        Producto p = dameCuenta(a);
        List<Movimientos>movi = p.getMovimientos();
        int i = 0;
        while(i<movi.size()){
            if(movi.get(i).getIdentificador().compareTo(a2)==0){
                aux = movi.get(i);
                i = movi.size();
            }
            else
                i++;
        }
        return aux;
    }

    //**********************************
    //******* TRANFERENCIAS ************
    //**********************************

    //REALIZAMOS UNA TRANSFERENCIA INTERNA
    public void realizarTranferenciaI(float cantidad, String origen, String destino) {
        Date d = new Date();
        Movimientos m = new OTransferencia();
        Movimientos m2 = new OTransferencia();
        Producto or = dameCuenta(origen);
        Producto de = dameCuenta(destino);
        //Ingreso y reintegros en las cuentas
        or.restar(cantidad);
        de.ingresar(cantidad);
        //Creacion del movimiento para el origen
        m.setConcepto("Tranferencia interna (reintegro)");
        m.setDinero(cantidad);
        m.setFecha(d);
        m.setCDestino(destino);
        or.incluirMovimiento(m);
        m.setProducto(or);
        //Creacion del movimiento para el destino
        m2.setConcepto("Tranferencia interna (ingreso)");
        m2.setDinero(cantidad);
        m2.setFecha(d);
        m2.setCDestino(destino);
        de.incluirMovimiento(m2);
        m2.setProducto(or);
    }

    //REALIZAMOS UNA TRANSFERENCIA EXTERNA
    public void realizarTranferenciaE(float cantidad, String origen, String destino) {
        Date d = new Date();
        Movimientos m = new OTransferencia();
        Producto or = dameCuenta(origen);
        //Reintegro de nuestra cuenta
        or.restar(cantidad);
        //Creacion del movimiento
        m.setConcepto("Tranferencia externa");
        m.setDinero(cantidad);
        m.setFecha(d);
        m.setCDestino(destino);
        or.incluirMovimiento(m);
        m.setProducto(or);
        //A la caja actual la decrementamos
        //cajaActual.decrementarSaldo(cantidad);

    }

    //***********************************
    //************* OTROS ***************
    //***********************************

    public void añadirProducto(Producto p) {
        mProducto.add(p);
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.484164A8-2613-63AD-6773-528381C30931]
    // </editor-fold> 
    public List<Caja> getCaja () {
        return mCaja;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.9E11BBE8-6CDB-F2EC-8809-CFEF1055CC74]
    // </editor-fold> 
    public void setCaja (List<Caja> val) {
        this.mCaja = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.776D671D-E2DF-3760-5206-7E7A12E11AED]
    // </editor-fold> 
    public List<Empleado> getEmpleado () {
        return mEmpleado;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.6D8FFDC1-508B-838E-8D36-8F191DB6E1E8]
    // </editor-fold> 
    public void setEmpleado (List<Empleado> val) {
        this.mEmpleado = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.963DB21C-9575-5840-87AF-72FA30E20A35]
    // </editor-fold> 
    public List<Producto> getProducto () {
        return mProducto;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.FDF7A684-9ABB-FAA6-646E-C9601A80DE01]
    // </editor-fold> 
    public void setProducto (List<Producto> val) {
        this.mProducto = val;
    }

    /**
     * @return the mClientesF
     */
    public List<ClienteFisico> getMClientesF() {
        return mClientesF;
    }

    /**
     * @param mClientesF the mClientesF to set
     */
    public void setMClientesF(List<ClienteFisico> mClientesF) {
        this.mClientesF = mClientesF;
    }

    /**
     * @return the mClientesJ
     */
    public List<ClienteJuridico> getMClientesJ() {
        return mClientesJ;
    }

    /**
     * @param mClientesJ the mClientesJ to set
     */
    public void setMClientesJ(List<ClienteJuridico> mClientesJ) {
        this.mClientesJ = mClientesJ;
    }

    /**
     * @return the cajaActual
     */
    public Caja getCajaActual() {
        return cajaActual;
    }

    /**
     * @param cajaActual the cajaActual to set
     */
    public void setCajaActual(Caja cajaActual) {
        this.cajaActual = cajaActual;
    }

    /**
     * @return the entidad
     */
    public Entidad getEntidad() {
        return entidad;
    }

    /**
     * @param entidad the entidad to set
     */
    public void setEntidad(Entidad entidad) {
        this.entidad = entidad;
    }


    /**
     * @return the empleadoActual
     */
    public Empleado getEmpleadoActual() {
        return empleadoActual;
    }

    /**
     * @param empleadoActual the empleadoActual to set
     */
    public void setEmpleadoActual(Empleado empleadoActual) {
        this.empleadoActual = empleadoActual;
    }

    //*******************************************************
    //****************** INICIO *****************************
    //*******************************************************

    //METODO QUE AÑADE UNA CAJA A LA LISTA DE CAJAS
    public void añadirCaja(Caja ca) {
        mCaja.add(ca);
    }

    //METODO QUE AÑADE UN EMPLEADO A LA LISTA DE EMPLEADOS
    public void añadirEmpleado(Empleado e) {
        mEmpleado.add(e);
    }

    //COMPRUEBA LA EXISTENCIA DEL EMPLEADO
    public boolean comprobarEmpleado(String login, String contraseña) {
        int i = 0;
        boolean encontrado = false;
        while(i<mEmpleado.size()&&encontrado==false){
            if(mEmpleado.get(i).getLogin().compareTo(login)==0)
                encontrado = true;
            else
                i++;
        }
        if(encontrado == false)
            return false;
        else
            if(mEmpleado.get(i).getPassword().compareTo(contraseña)==0)
                return true;
            else
                return false;
    }

    //DEVUELVE EL NOMBRE DE UN EMPLEADO DADO SU LOGIN
    public String dameNombreEmpleado(String login) {
        int i = 0;
        boolean encontrado = false;
        while(i<mEmpleado.size()&&encontrado==false){
            if(mEmpleado.get(i).getLogin().compareTo(login)==0)
                encontrado = true;
            else
                i++;
        }
        return mEmpleado.get(i).getNombre();
    }

    //CREA LA CAJA ACTUAL
    public void empezar(String login, String id) {
        Empleado em = new Empleado();
        int i = 0;
        boolean encontrado = false;
        while(i<mEmpleado.size()&&encontrado==false){
            if(mEmpleado.get(i).getLogin().compareTo(login)==0)
                encontrado = true;
            else
                i++;
        }
        em = mEmpleado.get(i);
        i = 0;
        encontrado = false;
         while(i<mCaja.size()&&encontrado==false){
            if(mCaja.get(i).getIdentificador().compareTo(id)==0)
                encontrado = true;
            else
                i++;
        }
        cajaActual = mCaja.get(i);
        cajaActual.setActual(em);
        empleadoActual = em;
    }

    //*************************************************
    //*************** PARTES DE DIFERENCIA ************
    //*************************************************

    /**
     * @return the mPartes
     */
    public List<PardeDiferencia> getMPartes() {
        return mPartes;
    }

    /**
     * @param mPartes the mPartes to set
     */
    public void setMPartes(List<PardeDiferencia> mPartes) {
        this.mPartes = mPartes;
    }

    public void crearParteDiferencia(double cantidad, String concepto) {
        Date d = new Date();
        PardeDiferencia p = new PardeDiferencia();
        p.setConcepto(concepto);
        p.setDiferencia(cantidad);
        p.setCaja(cajaActual);
        p.setEmpleado(empleadoActual);
        p.setFecha(d);
        mPartes.add(p);
    }

    //*************************************************
    //*************** REMESAS *************************
    //*************************************************

    /**
     * @return the mRemesas
     */
    public List<Remesa> getMRemesas() {
        return mRemesas;
    }

    /**
     * @param mRemesas the mRemesas to set
     */
    public void setMRemesas(List<Remesa> mRemesas) {
        this.mRemesas = mRemesas;
    }


    //REMESA CARGO
    public String verRemesa (String path) {
        String resumenRemesa="";
        try {
            FileReader fr = null;
            fr = new FileReader(path);
            if(fr == null){
                setMensajeError("Error en remesa, dirección\n"+path+" es erronea");
            }
            else{
            BufferedReader bf = new BufferedReader(fr);
            String linea, buffer;

            while ((linea = bf.readLine()) != null) {
                buffer=linea.substring(0,4);
                if(buffer.compareTo("5180")==0){
                    //Registro cabecera presentador
                    resumenRemesa=linea.substring(28,69);
                }else if(buffer.compareTo("5680")==0){
                    //Registro individual obligatorio
                    resumenRemesa += "\n"+linea.substring(28,68);
                    resumenRemesa += "\t"+linea.substring(88,98);
                 }else if(buffer.compareTo("5980")==0){
                     //Registro total final
                    resumenRemesa += "\nTotal Remesa: "+linea.substring(88,98);
                 }
            }
            }
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }
        return resumenRemesa;
    }

    //REMESA CARGO
    public void incorporarRemesa (String path) throws ParseException {
    System.out.println("\n\n***************REMESA CARGO*****************");
        try {
            FileReader fr = null;
            fr = new FileReader(path); //cogemos el fichero
            BufferedReader bf = new BufferedReader(fr);
            String linea; //donde iremos leyendo
            String fechaRemesa=""; //fecha de la remesa
            String numCta=""; //numero de cuenta
            Remesa r=new Remesa(); //nueva remesa
            //PARA LA DOMICILIACION
            String nombreOrdenante = "";
            while ((linea = bf.readLine()) != null) { //leemos hasta el final
                String buffer;
                buffer = linea.substring(0, 4);

                if(buffer.compareTo("5180")==0){
                    //registro cabecera presentador
                    r.setNombreOrdenante(linea.substring(28,68)); //le damos el ordenante a la remesa
                    //COGEMOS EL NOMBRE DLE ORDENANTE PARA LA DOMICILIACION
                    nombreOrdenante = linea.substring(28,68);
                }else if(buffer.compareTo("5380")==0){
                    fechaRemesa=linea.substring(22, 28); //nos cogemos la fecha
                }else if(buffer.compareTo("5680")==0){
                    OReintegro op=new OReintegro(); //nueva operacion de reintegro
                    DecimalFormat df1=new DecimalFormat("#######,##");
                    Number n=df1.parse(linea.substring(88, 98));
                    //leo el numcta
                    numCta=linea.substring(68,88); //cogemos el numero de cuenta
                    //devuelveproducto(numcta)
                    Producto auxCta=this.dameCuenta(numCta); //nos hacemos del producto
                    if(auxCta.getTipo().compareTo("")==0){ //si no existe la cuenta
                        System.out.println("Error en remesa, cuenta "+numCta+" inexistente");
                        this.setMensajeError("Error en remesa, cuenta "+numCta+" inexistente");
                    }
                    else{
                        if(n.floatValue()>auxCta.getDinero()){
                            System.out.println("Error en remesa, la cuenta "+numCta+" no tiene tanto dinero");
                            this.setMensajeError("Error en remesa, la cuenta "+numCta+" no tiene tanto dinero");
                        }
                        else{
                            op.setDinero(n.floatValue());
                            op.setConcepto(r.getNombreOrdenante());
                            SimpleDateFormat df2=new SimpleDateFormat("ddMMyy");
                            op.setFecha(df2.parse(fechaRemesa));
                            r.insertaOpRemesa(op);
                            //insertar movimiento en su producto
                            auxCta.incluirMovimiento(op); //al producto le incluimos le nuevo movimiento
                            //AÑADIMOS LA DOMICILIACION AL PRODUCTO
                            auxCta.añadirDomiciliacion(nombreOrdenante);
                            //LE RESTAMOS EL DINERO A LA CUENTA
                            auxCta.restar(n.floatValue());
                            this.setMensajeError("Remesa creada correctamente");
                    }
                    }
                }

            }
            this.insertaRemesaenSucursal(r);
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }
System.out.println("**********************************************");
}
    public void insertaRemesaenSucursal(Remesa r){
        this.mRemesas.add(r);
    }

    //REMESA ABONO
    public String verRemesaAbono(String path) {
        String resumenRemesa="";
        try {
            FileReader fr = null;
            fr = new FileReader(path);
            if(fr==null){
                setMensajeError("Error en remesa, dirección "+path+" es erronea");
            }
            else{
            BufferedReader bf = new BufferedReader(fr);
            String linea, buffer;
            while ((linea = bf.readLine()) != null) {
                buffer=linea.substring(0,4);
                //0356 TRATA LAS NOMINAS DESDE EL ORDENANTE
                if(buffer.compareTo("0356")==0){
                    //REGISTRO CABECERA ORDENANTE
                    buffer=linea.substring(26,29); //TIPO
                    if(buffer.compareTo("001")==0){ //SI ES CON 001 VIENE CON FECHA Y DEMAS
                        resumenRemesa += "Cuenta del cargo: "+linea.substring(41,45)+ "  "; //ENTIDAD DE DESTINO
                        resumenRemesa += linea.substring(45,49)+"  "; //NUMERO DE SUCURSAL DE LA CUENTA DE CARGO
                        resumenRemesa += linea.substring(49,59)+'\n'+'\n'; //NUMERO DE LA CUENTA DE CARGO
                    }
                    else{
                        resumenRemesa += linea.substring(29,65)+'\n'; //NOMBRE ORDENANTE
                    }
                //0656 TRATA LAS NOMINAS PERO DEL BENEFICIARIO
                }else if(buffer.compareTo("0656")==0){
                    //REGISTRO INDIVIDUAL
                    buffer = linea.substring(26,29); //TIPO
                    if(buffer.compareTo("010")==0){
                        resumenRemesa += "\nCuenta beneficiario: "+linea.substring(41,59); //DATOS BENEFICIARIO
                        resumenRemesa += " || importe "+Double.valueOf(linea.substring(29,41))+" €"; //IMPORTE
                    }
                    else{
                        resumenRemesa += " "+linea.substring(29,65); //NOMBRE DEL BENEFICIARIO
                    }
                 //0806 TRATA LAS NOMINAS PERO ES EL FINAL
                 }else if(buffer.compareTo("0856")==0){
                    //REGISTRO FINAL CON LOS TOTALES
                    resumenRemesa += "\n\n Total Remesa: "+Double.valueOf(linea.substring(29,41))+" €";
                 }
            }
            }
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }
        return resumenRemesa;
    }

    //REMESA ABONO
    public void incorporarRemesaAbono(String path) throws ParseException {
    System.out.println("\n\n***************REMESA ABONO******************");
        try {
            FileReader fr = null;
            fr = new FileReader(path);
            BufferedReader bf = new BufferedReader(fr);
            String linea, buffer;
            
            Remesa r = new Remesa();
            OReintegro op=new OReintegro();
            String nombreOrdenante="";
            String fecha="";
            String cuenta="";
            float importe=0;
            float total=0;
            
            while ((linea = bf.readLine()) != null) {
                buffer=linea.substring(0,4);
                //0356 TRATA LAS NOMINAS DESDE EL ORDENANTE
                if(buffer.compareTo("0356")==0){
                    //REGISTRO CABECERA ORDENANTE
                    buffer=linea.substring(26,29); //TIPO
                    if(buffer.compareTo("001")==0){ //SI ES CON 001 VIENE CON FECHA Y DEMAS
                        fecha+=linea.substring(29,35); //LA FECHA
                    }
                    else{
                        nombreOrdenante += linea.substring(29,65)+'\n'; //NOMBRE ORDENANTE
                    }
                //0656 TRATA LAS NOMINAS PERO DEL BENEFICIARIO
                }else if(buffer.compareTo("0656")==0){
                    //REGISTRO INDIVIDUAL
                    buffer = linea.substring(26,29); //TIPO
                    if(buffer.compareTo("010")==0){
                        cuenta = linea.substring(41,59); //DATOS BENEFICIARIO
                        importe = Float.valueOf(linea.substring(29,41)); //IMPORTE

            //devuelveproducto(numcta)
            Producto auxCta=this.dameCuenta(cuenta); //nos hacemos del producto
            if(auxCta.getTipo().compareTo("")==0){
                System.out.println("Error en remesa, cuenta "+cuenta+" inexistente");
                setMensajeError("Error en remesa, cuenta "+cuenta+" inexistente");
            }
            else{
            op.setDinero(importe);
            op.setConcepto(nombreOrdenante);
            SimpleDateFormat df2=new SimpleDateFormat("ddMMyy");
            op.setFecha(df2.parse(fecha));
            r.insertaOpRemesa(op);
            //insertar movimiento en su producto
            auxCta.incluirMovimiento(op); //al producto le incluimos le nuevo movimiento
            //AÑADIMOS LA DOMICILIACION AL PRODUCTO
            auxCta.añadirDomiciliacion(nombreOrdenante);
            //LE RESTAMOS EL DINERO A LA CUENTA
            auxCta.ingresar(importe);
            r.setNombreOrdenante(nombreOrdenante);
            this.insertaRemesaenSucursal(r);
            this.setMensajeError("Remesa creada correctamente");
            }
                    }
                    else{
                        //resumenRemesa += " "+linea.substring(29,65); //NOMBRE DEL BENEFICIARIO
                    }

                 //0806 TRATA LAS NOMINAS PERO ES EL FINAL
                 }else if(buffer.compareTo("0856")==0){
                    //REGISTRO FINAL CON LOS TOTALES
                    total+=Float.valueOf(linea.substring(29,41));
                 }
            }
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }
    System.out.println("***********************************************");
    }

    /**
     * @return the mensajeError
     */
    public String getMensajeError() {
        return mensajeError;
    }

    /**
     * @param mensajeError the mensajeError to set
     */
    public void setMensajeError(String mensajeError) {
        this.mensajeError = mensajeError;
    }
    

    //*********************************************************
    //********************* EMPLEADOS *************************
    //*********************************************************

    public void crearEmpleado(String nombre, String apellidos, String telefono, String login, String contraseña) {
        Empleado nuevo = new Empleado();
        nuevo.crear(nombre,apellidos,telefono,login,contraseña);
        if(mEmpleado.size()==0){
            nuevo.setIdentificador(1);
        }
        else{
            nuevo.setIdentificador(mEmpleado.get(mEmpleado.size()-1).getIdentificador()+1);
        }
        this.mEmpleado.add(nuevo);
    }

    public Empleado dameEmpleado(String nombre) {
        int i = 0;
        Empleado aux = new Empleado();
        while(i<mEmpleado.size()){
            if(mEmpleado.get(i).getComparacion().compareTo(nombre)==0){
                aux = mEmpleado.get(i);
                i = mEmpleado.size();
            }
            else{
                i++;
            }
        }
        return aux;
    }

    public void crearArqueo(String tipo){
        Arqueo arqueo = new Arqueo();
        arqueo.setSaldo(this.cajaActual.getSaldo());
        arqueo.setTipo(tipo);
        arqueo.setFecha(new Date());
        arqueo.setRealizado(cajaActual);
        empleadoActual.añadirArqueo(arqueo);
    }

    public void modificarEmpleado(Empleado antiguo, String nombre, String apellidos, String telefono, String login, String contraseña) {
        antiguo.crear(nombre, apellidos, telefono, login, contraseña);
    }


    //**************************************************************
    //*********************** GUARDAR DATOS ************************
    //**************************************************************

    public void guardar(){
        ControladorBD cbd = new ControladorBD();
        for(int i = 0;i<getProducto().size();i++){
            //System.out.println(mProducto.get(i).getNumeroCuenta());
            cbd.add(getProducto().get(i));
        }
        for(int i = 0;i<getMClientesJ().size();i++)
            cbd.add(getMClientesJ().get(i));
        for(int i = 0;i<getMClientesF().size();i++)
            cbd.add(getMClientesF().get(i));
        try {
            this.generarTranferencias();
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    
    //**************************************************************
    //********** GENERACION DLE FICHERO TRANFERENCIAS **************
    //**************************************************************

    public void generarTranferencias() throws IOException{
        FileWriter fw = null;
        float total = 0;
        fw = new FileWriter("C:\\Remesas\\transferencias.txt");
        if(fw == null){
            System.out.println("\n\n*********************\nERROR EN GENERACION\n********************");
        }
        else{
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write("0356");
            bw.newLine();
            bw.write("001");
            bw.newLine();
            bw.write("Odenante BBUVA");
            bw.newLine();
            bw.write("Creacion: "+new Date());
            bw.newLine();
            bw.write("*********************");
            for(int i = 0;i<mProducto.size();i++){
                for(int j = 0;j<mProducto.get(i).getMovimientos().size();j++){
                if(mProducto.get(i).getMovimientos().get(j).getConcepto().compareTo("Tranferencia interna (reintegro)")==0){
                    bw.newLine();
                    bw.write("002");
                    bw.newLine();
                    bw.write(mProducto.get(i).getMClientes().get(0).getDatos());
                    bw.newLine();
                    bw.write(mProducto.get(i).getNumeroCuenta());
                    bw.newLine();
                    bw.write(mProducto.get(i).getMovimientos().get(j).getConcepto());
                    bw.newLine();
                    bw.write(String.valueOf(mProducto.get(i).getMovimientos().get(j).getDinero()));
                    total += mProducto.get(i).getMovimientos().get(j).getDinero();
                    bw.newLine();
                    bw.write(String.valueOf(mProducto.get(i).getMovimientos().get(j).getFecha()));
                }
                if(mProducto.get(i).getMovimientos().get(j).getConcepto().compareTo("Tranferencia externa")==0){
                    bw.newLine();
                    bw.write("002");
                    bw.newLine();
                    bw.write(mProducto.get(i).getMClientes().get(0).getDatos());
                    bw.newLine();
                    bw.write(mProducto.get(i).getNumeroCuenta());
                    bw.newLine();
                    bw.write(mProducto.get(i).getMovimientos().get(j).getConcepto());
                    bw.newLine();
                    bw.write(String.valueOf(mProducto.get(i).getMovimientos().get(j).getDinero()));
                    total += mProducto.get(i).getMovimientos().get(j).getDinero();
                    bw.newLine();
                    bw.write(String.valueOf(mProducto.get(i).getMovimientos().get(j).getFecha()));
                }
                }
            }
            bw.newLine();
            bw.write("***************************");
            bw.newLine();
            bw.write("0856");
            bw.newLine();
            bw.write("Importe total en tranferencias: "+total);
            bw.close();
        }
    }

}

