package Modelo;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
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.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;


// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
// #[regen=yes,id=DCE.F6ADC267-7896-6E10-0302-A5E8B022AE3F]
// </editor-fold> 
public class Sucursal {

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.24301496-C66B-ED4E-58AD-BC08B97D0F20]
    // </editor-fold> 
    private List<Producto> mProducto;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.35C55C5A-F75F-43DE-EB4C-274D79095BBF]
    // </editor-fold> 
    private ArrayList<Remesa> mRemesa;

    private List<Cliente> mCliente;
    private ArrayList<Empleado> mEmpleado;
    private ArrayList<Caja> mCaja;

    private ArrayList<ParteDiferencia> mParte;

    private String stCCOpera;
    private Empleado empleadoActivo;

    private double idParte;

    //Para generar las cuentas
    //private static int incrementaCuenta;
    private int iCuenta;
    private String mensaje;
    
    //Para almacenar las T_Externa y generar la remesa saliente;
    private ArrayList<T_Externa> mT_Externa;

    

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.C1FFA6F3-2A70-CCD5-4BCA-820B9BA4E4BF]
    // </editor-fold> 
    public Sucursal () {
        mProducto=new ArrayList();
        mRemesa=new ArrayList();
        mCliente=new ArrayList();
        mEmpleado=new ArrayList();
        mCaja=new ArrayList();
        mParte=new ArrayList();
        stCCOpera = "";
        mensaje = "";
        mT_Externa = new ArrayList();
        
        mCaja.add(new Caja(0)); //Array List Caja principal introducida

        iCuenta=5671234;
    }
    
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.F9B3703C-EB97-7CC3-8FE1-06153FB4DFEF]
    // </editor-fold> 
    public List<Producto> getProducto () {
        return mProducto;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.D1F674F8-817C-0A8D-C6F2-99AD1F9CCA7D]
    // </editor-fold> 
    public void setProducto (List<Producto> val) {
        this.mProducto = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.01ADB45C-0D5D-C657-87A4-C6A632CE3CD9]
    // </editor-fold> 
    public ArrayList<Remesa> getRemesa () {
        return mRemesa;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.7CDDD229-A67D-3979-090F-7478CEB92848]
    // </editor-fold> 
    public void setRemesa (ArrayList<Remesa> val) {
        this.mRemesa = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.80C35FDE-A9A2-C741-2D07-A24D3516D4FB]
    // </editor-fold> 
    public void nuevaRemesaCargos () {
    }

// ****************************************************************************
// ****************************************************************************

// ****************************************************************************

    // METODOS PARA LA GESTION DE LAS REMESAS

// ****************************************************************************

    public String verRemesaCargos(String path)
    {
        String stResumenRemesa="";
        FileReader fr = null;
        try {
        fr = new FileReader(path);
        BufferedReader bf = new BufferedReader(fr);
        String linea;
        String buf;
        while((linea=bf.readLine())!=null){

            buf = linea.substring(0, 4);

            if (buf.compareTo("5180") == 0)
            {
                //Registro cabecera presentador
                stResumenRemesa = "\n" + linea.substring(28, 68);
                stResumenRemesa += "\n";
                
            } else if (buf.compareTo("5680") == 0)
                {
                    //Registro individual obligatorio
                    stResumenRemesa += "\n" + linea.substring(28, 68);
                    stResumenRemesa += "\t" + linea.substring(88, 98);
                } else if (buf.compareTo("5980") == 0)
                    {
                        //Registro total final
                        stResumenRemesa += "\n\n\tTotal Remesa: " + linea.substring(88, 98);
                    }
            //tratamiento de la linea, con método String substring( int beginindex,int endindex );
        }
        } catch (IOException ex)
            {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
            }
        return stResumenRemesa;
    }

    public void incorporarRemesa(String path) throws ParseException
    {
        FileReader fr = null;
        try {
        fr = new FileReader(path);
        BufferedReader bf = new BufferedReader(fr);
        String linea;
        String buf;
        String stFechaRem = "";
        String numCta = "";
        Remesa r = new Remesa();

        while((linea=bf.readLine())!=null){

            buf = linea.substring(0, 4);

            if (buf.compareTo("5180") == 0)
            {
                //Registro cabecera presentador
                r.setNombreOrdenante(linea.substring(28, 68));
                
            } else if (buf.compareTo("5380") == 0)
                {
                    //Registro cabecera ordenante
                    stFechaRem = linea.substring(22, 28);
                } else if (buf.compareTo("5680") == 0)
                    {
                        //Registro individual obligatorio
                        Op_Remesa op = new Op_Remesa();

                        DecimalFormat df1 = new DecimalFormat("#######,##");
                        Number n = null;
                        
                        try
                        {
                            n = df1.parse(linea.substring(88, 98));
                        }
                            catch (ParseException ex)
                            {
                                Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
                            }

                         //Leo el numero de cuenta.
                        numCta=linea.substring(68,88);


                        
                        // Si la cuenta existe
                        if(this.bExisteCuenta(numCta))
                        {
                            //Ejecuto devuelve producto y le paso el numero de cuenta.
                            Producto auxCta = this.devuelveProducto(numCta);
                            
                            if(n.doubleValue() > auxCta.getDSaldo())
                            {
                                this.GestionErroresRemesas(2);
                                return;
                            }
                            
                            else
                            {
                                op.setDImporte(n.intValue()*(-1));
                                op.setStConcBreve(r.getNombreOrdenante());

                                SimpleDateFormat df2 = new SimpleDateFormat("ddMMyy");
                                op.setDatOpe(df2.parse(stFechaRem));

                                r.InsertOp_Remesa(op);
                                //Insertar movimiento en su producto.
                                auxCta.insertaMovimientoenCuenta(op);

                                //Decremento Caja Central
                                this.decrementoCaja(n.intValue(), 0);

                                if(bExisteDomiciliacion(numCta,r.getNombreOrdenante()))
                                {
                                    Domiciliacion d = new Domiciliacion();

                                    d = dameDomiciliacion(numCta,r.getNombreOrdenante());

                                    d.setDCantidad(n.doubleValue()*(-1));
                                    d.setDUltima(new Date());
                                } 
                                
                                else
                                {
                                    Domiciliacion d = new Domiciliacion();

                                    d.setStOrdenante(r.getNombreOrdenante());
                                    d.setDCantidad(n.doubleValue()*(-1));
                                    d.setDUltima(new Date());

                                    this.incluyeDomiciliacion(numCta,d);
                                    
                                    
                                }
                                    this.GestionErroresRemesas(3);
                                
                             }
                            
                            
                        }
                        
                        // Si la cuenta no existe
                        else{this.GestionErroresRemesas(1);}
                            
                            
                }
        }
        } catch (IOException ex)
            {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
            }
    }

    public String verRemesaAbonos( String path)
    {
        String stResumenRemesa="";
        FileReader fr = null;
        try {
        fr = new FileReader(path);
        BufferedReader bf = new BufferedReader(fr);
        String linea;
        String buf;
        
        while((linea=bf.readLine())!=null){

            buf = linea.substring(0, 4);

            if (buf.compareTo("0356") == 0)
            {
                //Registro cabecera presentador
                buf = linea.substring(26,29);
                
                if (buf.compareTo("001") == 0)
                    {
                        stResumenRemesa += "\n" + linea.substring(41,49);
                        stResumenRemesa += linea.substring(63,65);
                        stResumenRemesa += linea.substring(49,59);
                    }else
                        {
                            stResumenRemesa += "\n" + linea.substring(29,70);
                        }
            } else if (buf.compareTo("0856") == 0)
                {
                    //Registro final
                
                    double dImpT = Double.valueOf(linea.substring(29, 41));
                    dImpT = dImpT/100;
                    stResumenRemesa += "\n\n\tTotal Remesa: " + dImpT;
                } else
                    {
                        //Registro individual
                        if (linea.substring(26, 29).compareTo("010") == 0)
                        {
                            stResumenRemesa += "\n\nCuenta: " + linea.substring(41,49);
                            stResumenRemesa += linea.substring(63,65);
                            stResumenRemesa += linea.substring(49,59);

                            double dImp = Double.valueOf(linea.substring(29,41));
                            dImp = dImp/100;

                            stResumenRemesa += "\tImporte: " + dImp;
                        }
                        if (linea.substring(26, 29).compareTo("011") == 0)
                        {
                            stResumenRemesa += "\nTitular: " + linea.substring(29,65);
                        }
                        if (linea.substring(26, 29).compareTo("016") == 0)
                        {
                            stResumenRemesa += "\tConcepto: " + linea.substring(29,65);
                        }
                    }
        }
        } catch (IOException ex)
            {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
            }
        
        return stResumenRemesa;
    }

    public void incorporarRemesaAbonos( String path) throws ParseException
    {
        FileReader fr = null;
        
        
        try {
        fr = new FileReader(path);
        
        BufferedReader bf = new BufferedReader(fr);
        String linea;
        String buf;
        
        String stOrdenante = "";
        String stCuentaOrigen = "";
        String stFechaRem = "";
        double dImpTotal = 0;
        

        while((linea=bf.readLine())!=null)
        {

            buf = linea.substring(0, 4);
            Remesa r = new Remesa();

            if (buf.compareTo("0356") == 0)
            {
                
                //Registro cabecera presentador
                buf = linea.substring(26,29);

                if (buf.compareTo("001") == 0)
                    {
                        stCuentaOrigen += linea.substring(41,49);
                        stCuentaOrigen += linea.substring(63,65);
                        stCuentaOrigen += linea.substring(49,59);
                        
                        stFechaRem = linea.substring(35, 41);
                    }else if (buf.compareTo("002") == 0)
                        {
                            stOrdenante = linea.substring(29,70);
                            r.setNombreOrdenante(stOrdenante);
                        }
            } else if (buf.compareTo("0856") == 0)
                {
                    //Registro final
                    
                    DecimalFormat df1 = new DecimalFormat("#######,##");
                    Number n = null;
                    n = df1.parse(linea.substring(29, 41));
                    
                    dImpTotal = n.doubleValue();
                    dImpTotal = dImpTotal/100;
                    
                } else
                    {
                        //Registro individual
                
                        if (linea.substring(26, 29).compareTo("010") == 0)
                        {
                            Op_Remesa op = new Op_Remesa();
                        
                            DecimalFormat dfImp = new DecimalFormat("#######,##");
                            Number n = null;
                    
                            n = dfImp.parse(linea.substring(29, 41));

                            //Leo el numero de cuenta.
                            String stCCDestino = linea.substring(41,49);
                            stCCDestino += linea.substring(63,65);
                            stCCDestino += linea.substring(49,59);
                            //Ejecuto devuelve producto y le paso el numero de cuenta.
                            Producto auxCta = this.devuelveProducto(stCCDestino);
                            
                                      
                            

                            // Controla si la cuenta origen existe
                            if(this.bExisteCuenta(stCCDestino))
                            {
                                double dImp = n.doubleValue();
                                dImp = dImp / 100;
                                op.setDImporte(dImp);
                                op.setStConcBreve(stOrdenante);

                                SimpleDateFormat df2 = new SimpleDateFormat("ddMMyy");
                                op.setDatOpe(df2.parse(stFechaRem));

                                r.InsertOp_Remesa(op);

                                //Insertar movimiento en su producto.
                                auxCta.insertaMovimientoenCuenta(op);

                                this.GestionErroresRemesas(3);
                            }
                            else
                            {
                                this.GestionErroresRemesas(1);
                                return;
                            }
                        }
                    }
        }

        Op_Remesa op2 = new Op_Remesa();
        SimpleDateFormat df2 = new SimpleDateFormat("ddMMyy");


        Producto auxCta = this.devuelveProducto(stCuentaOrigen);

        if(this.bExisteCuenta(stCuentaOrigen))
             {
                    if(dImpTotal > auxCta.getDSaldo())
                            {
                                this.GestionErroresRemesas(2);
                                return;
                            }
                    else
                    {
                        op2.setDImporte(dImpTotal * (-1));
                        op2.setDatOpe(df2.parse(stFechaRem));
                        op2.setStConcBreve("Operacion de Remesa");
                        op2.setStRemitente("El Banco");
                        auxCta.insertaMovimientoenCuenta(op2);

                        this.GestionErroresRemesas(3);
                    }
             }
        
             else
             {
                 this.GestionErroresRemesas(1);
             }
         
        
        } catch (IOException ex)
            {
            
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
            }
    }

    public void InsertRemesaInSuc(Remesa r)
    {
        this.mRemesa.add(r);
    }

// ****************************************************************************
// ****************************************************************************

// ****************************************************************************

    // METODOS PARA LA GESTION DE MOVIMIENTOS

// ****************************************************************************
    public Producto devuelveProducto(String numCuenta)
    {
        Iterator iterador = this.mProducto.listIterator();

        while( iterador.hasNext() ) {
            Producto p = (Producto) iterador.next();
            if (p.getStNumPro().compareTo(numCuenta)==0){
                return p;
            }
        }
        return null;
    }

    public void RegistraMovimiento(Op_Basica op)
    {
        Producto auxCta = this.devuelveProducto(op.getStCuentaCorriente());
        
        if (op.getDImporte() > 0)
        {
            //auxCta.setDSaldo(auxCta.getDSaldo() + op.getDImporte());
            auxCta.insertaMovimientoenCuenta(op);
        } else
            {
                if(Math.abs(op.getDImporte()) < auxCta.getDSaldo())
                {
                    //auxCta.setDSaldo(auxCta.getDSaldo() + op.getDImporte());
                    auxCta.insertaMovimientoenCuenta(op);
                } else
                    {
                        System.out.println("SALDO INSUFICIENTE.");
                    }
            }        
    }

    public void setMCliente(List<Cliente> mCliente) {
        this.mCliente = mCliente;
    }

    public List<Producto> busquedaProductosCliente(String datosClte, int tipoBusq){
        //ArrayList<Producto> AP=new ArrayList();

        //ArrayList<Cliente> c=this.getMCliente();

        Iterator iterador = this.mCliente.listIterator();

        while( iterador.hasNext() ) {
            Cliente c = (Cliente) iterador.next();
            if(tipoBusq==1){
                if(c.getDocumentacion().compareToIgnoreCase(datosClte)==0){
                    return c.getMProducto();
                }
            }else{
                if(tipoBusq==2){
                    if (c.getNombreCliente().compareToIgnoreCase(datosClte)==0){
                    return c.getMProducto();

                    }
                }
            }

        }
        return null;
    }

// ****************************************************************************
// ****************************************************************************

// ****************************************************************************

    // METODOS PARA LA CREACION DE PRODUCTOS

// ****************************************************************************

    public void crearLA(String stName, String stLA,String stDoc) {
        Cliente C = new Cliente();
        Controlador ConAux = new Controlador();
        if (this.bExisteCliente(stDoc))
        {
            Cliente CAux = this.devuelveClienteSucursal(stDoc);
            

            Producto P = new LtaAhorro();
            P.setDSaldo(0);
            P.setNumeroProducto(stLA);


            CAux.insertaProductoenCliente(P);
            P.insertaTitularenProducto(CAux);

            this.mProducto.add(P);

            ConAux.crearClienteBD(CAux.getDocumentacion(), CAux.getNombreCliente(), P.getStNumPro());
        }

        else
        {
            C.setNombreCliente(stName);
            C.setDocumentacion(stDoc);
            Producto P = new LtaAhorro();
            P.setDSaldo(0);
            P.setNumeroProducto(stLA);

            C.insertaProductoenCliente(P);
            P.insertaTitularenProducto(C);
            this.mProducto.add(P);
            this.mCliente.add(C);

            ConAux.crearClienteBD(C.getDocumentacion(), C.getNombreCliente(),P.getStNumPro());

        }
    }

    public void crearCC(String stName, String stCC, String stDoc) {
        Cliente C = new Cliente();
        Controlador ConAux = new Controlador();

        if (this.bExisteCliente(stDoc))
        {
            Cliente CAux = this.devuelveClienteSucursal(stDoc);

            Producto P = new CtaCorriente();
            P.setDSaldo(0);
            P.setNumeroProducto(stCC);

            
            CAux.insertaProductoenCliente(P);
            P.insertaTitularenProducto(CAux);

            this.mProducto.add(P);

            ConAux.crearClienteBD(CAux.getDocumentacion(), CAux.getNombreCliente(),P.getStNumPro());
        }

        else
        {
            C.setNombreCliente(stName);
            C.setDocumentacion(stDoc);
            Producto P = new CtaCorriente();
            P.setDSaldo(0);
            P.setNumeroProducto(stCC);

            C.insertaProductoenCliente(P);
            P.insertaTitularenProducto(C);
            this.mProducto.add(P);
            this.mCliente.add(C);

            ConAux.crearClienteBD(C.getDocumentacion(), C.getNombreCliente(),P.getStNumPro());

        }


    }

    public void crearPH(String stCC, double dImporte, String stConcepto, int iAnos) {

        //auxCta.insertaMovimientoenCuenta(op);

        Producto P = new PrestamoHipotecario();
        P.setDSaldo(dImporte);
        P.setNumeroProducto(stCC);

        Producto Pcta = this.devuelveProducto(stCC);
        Op_Basica obAux = new Op_Basica();
        obAux.setDImporte(dImporte);
        obAux.setStConcBreve("Prestamo Hipotecario");
        obAux.setStCuentaCorriente(stCC);
        obAux.setStRemitente("Swindler Bank E.S.");

        Date d = new Date();
        obAux.setDatOpe(d);
        
        Pcta.insertaMovimientoenCuenta(obAux);

        PrestamoHipotecario PH = new PrestamoHipotecario();
       
        PH.setNCC(stCC);
        PH.setImporte(dImporte);
        PH.setConcepto(stConcepto);
        PH.setAnos(iAnos);

        this.mProducto.add(P);

        decrementoCaja(dImporte, 0);
    }

    public void crearPP(String stCC, double dImporte, String stConcepto, int iAnos) {

        Producto P = new PrestamoPersonal();
        P.setDSaldo(dImporte);
        P.setNumeroProducto(stCC);

        Producto Pcta = this.devuelveProducto(stCC);
        Op_Basica obAux = new Op_Basica();
        obAux.setDImporte(dImporte);
        obAux.setStConcBreve("Prestamo Hipotecario");
        obAux.setStCuentaCorriente(stCC);
        obAux.setStRemitente("Swindler Bank E.S.");

        Date d = new Date();
        obAux.setDatOpe(d);

        Pcta.insertaMovimientoenCuenta(obAux);

        PrestamoPersonal PP = new PrestamoPersonal();

        PP.setNCC(stCC);
        PP.setImporte(dImporte);
        PP.setConcepto(stConcepto);
        PP.setAnos(iAnos);

        this.mProducto.add(P);

        decrementoCaja(dImporte, 0);
    }


    public boolean bExisteCliente(String stDNI)
    {
        Iterator iterador = this.mCliente.listIterator();

        while( iterador.hasNext() ) {
            Cliente c = (Cliente) iterador.next();
            if (c.getDocumentacion().compareToIgnoreCase(stDNI)==0)
                {
                    return true;}
            }
        return false;
    }

    public Cliente devuelveClienteSucursal(String stDNI)
    {
        Iterator iterador = this.mCliente.listIterator();

        while( iterador.hasNext() ) {
            Cliente c = (Cliente) iterador.next();
            if (c.getDocumentacion().compareToIgnoreCase(stDNI)==0)
                {
                    return c;}
            }
        return null;
    }

    public List<Producto> busquedaProductosCliente(String datosClte)
    {
        Iterator iterador = this.mCliente.listIterator();

        while( iterador.hasNext() ) {
            Cliente c = (Cliente) iterador.next();
            if (c.getNombreCliente().compareToIgnoreCase(datosClte)==0)
                {
                    return c.getMProducto();}
            }
        return null;
    }


public String CrearCuentaDeterminada()
{
    String cadena="2098400210000";
    this.setiCuenta(this.iCuenta+1);
    String res =  Integer.toString(this.getiCuenta());
    return cadena + res;
}

    /**
     * @return the stCuenta
     */
    public int getiCuenta() {
        return iCuenta;
    }

    /**
     * @param stCuenta the stCuenta to set
     */
    public void setiCuenta(int stCuenta) {
        this.iCuenta = stCuenta;
    }


 // ****************************************************************************
// ****************************************************************************

// ****************************************************************************

    // METODOS PARA LAS TRANSFERENCIAS

// ****************************************************************************

    public void RegistraTrans_Int(T_Interna auxMov) {
        Producto CtaOrigen = this.devuelveProducto(auxMov.getStCCOrigen());
        Producto CtaDestino = this.devuelveProducto(auxMov.getStCCDestino());
        
        if ( auxMov.getDImporte() > CtaOrigen.getDSaldo() )
        {
            System.out.println("SALDO INSUFICIENTE.");
        } else
            {
                //CtaDestino.setDSaldo(CtaDestino.getDSaldo() + auxMov.getDImporte());
                CtaDestino.insertaMovimientoenCuenta(auxMov);

                T_Interna auxMov2 = new T_Interna();

                auxMov2.setDImporte(auxMov.getDImporte() * (-1));
                auxMov2.setDatOpe(auxMov.getDatOpe());
                auxMov2.setStCCDestino(auxMov.getStCCDestino());
                auxMov2.setStCCOrigen(auxMov.getStCCOrigen());
                auxMov2.setStConcBreve(auxMov.getStConcBreve());
                auxMov2.setStRemitente(auxMov.getStRemitente());
                
                //CtaOrigen.setDSaldo(CtaOrigen.getDSaldo() + auxMov2.getDImporte());
                CtaOrigen.insertaMovimientoenCuenta(auxMov2);
            }
    }

    public void RegistraTrans_Ext(T_Externa auxMov) {
        Producto CtaOrigen = this.devuelveProducto(auxMov.getStCCOrigen());

        if ( (auxMov.getDImporte() + auxMov.getDComision()) > CtaOrigen.getDSaldo() )
        {
            System.out.println("SALDO INSUFICIENTE.");
        } else
            {
                Op_Basica comision = new Op_Basica();

                comision.setDImporte(auxMov.getDComision() * (-1));
                comision.setDatOpe(auxMov.getDatOpe());
                comision.setStCuentaCorriente(auxMov.getStCCOrigen());
                comision.setStConcBreve("Comision por Transferencia");
                comision.setStRemitente("Swindler Bank E.S.");

                auxMov.setDImporte(auxMov.getDImporte() * (-1));
                
                CtaOrigen.insertaMovimientoenCuenta(auxMov);
                CtaOrigen.insertaMovimientoenCuenta(comision);

                Op_Basica comBanco = new Op_Basica();

                comBanco.setDImporte(auxMov.getDComision());
                comBanco.setDatOpe(comision.getDatOpe());
                comBanco.setStCuentaCorriente("12345678900987654321");
                comBanco.setStConcBreve("Comision por Transferencia");
                comBanco.setStRemitente(auxMov.getStCCOrigen());

                Producto CtaBanco = this.devuelveProducto("12345678900987654321");

                CtaBanco.insertaMovimientoenCuenta(comBanco);

                this.almacenaT_Externa(auxMov);
            }
    }

    
    /**
     * @return the stCCOpera
     */
    public String getStCCOpera() {
        return stCCOpera;
    }

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


// ****************************************************************************
// ****************************************************************************


// ****************************************************************************

    // METODOS PARA LOS EMPLEADOS

// ****************************************************************************

    
    public void insertaEmpleadoenSucursal(Empleado emp){
        this.getMEmpleado().add(emp);
    }

    /**
     * @return the mEmpleado
     */
    public ArrayList<Empleado> getMEmpleado() {
        return mEmpleado;
    }

    /**
     * @param mEmpleado the mEmpleado to set
     */
    public void setMEmpleado(ArrayList<Empleado> mEmpleado) {
        this.mEmpleado = mEmpleado;
    }
    
    public boolean busquedaEmpleadosSucursal(String datosEmpleados)
    {
        Iterator iterador = this.mEmpleado.listIterator();

        while( iterador.hasNext() ) {
            Empleado e = (Empleado) iterador.next();
            if (e.getStDNIEmpleado().compareToIgnoreCase(datosEmpleados)==0)
                {
                    return true;}
            }
        return false;
    }
    
    public Empleado devuelveEmpleadosSucursal(String datosEmpleados)
    {
        Iterator iterador = this.mEmpleado.listIterator();

        while( iterador.hasNext() ) {
            Empleado e = (Empleado) iterador.next();
            if (e.getStDNIEmpleado().compareToIgnoreCase(datosEmpleados)==0)
                {
                    return e;}
            }
        return null;
    }

    /**
     * @return the empleadoActivo
     */
    // Metodo que nos devuelve el empleado que esta interactuando
    public Empleado getEmpleadoActivo() {
        return empleadoActivo;
    }

    /**
     * @param empleadoActivo the empleadoActivo to set
     */

    // Metodo que registra el empleado que esta activo
    public void setEmpleadoActivo(Empleado empleadoActivo) {
        this.empleadoActivo = empleadoActivo;
    }

    // Metodo que nos devuelve el dni del empleado activo
    public String dameDNIEmpleado()
    {
         Empleado e = this.getEmpleadoActivo();
         return e.getStDNIEmpleado();

    }

// ****************************************************************************
// ****************************************************************************
    
    
// ****************************************************************************
    
    // METODOS PARA LAS CAJAS
    
// ****************************************************************************


    /**
     * @return the mCaja
     */
    // devolver Caja del ArrayList
    public ArrayList<Caja> getMCaja() {
        return mCaja;
    }

    /**
     * @param mCaja the mCaja to set
     */
    // añadir caja al arraylist
    public void setMCaja(ArrayList<Caja> mCaja) {
        this.mCaja = mCaja;
    }


    // Metodo que nos devulve un objeto Caja pasandole su id
    public Caja busquedaCajaSucursal(double id)
    {
    Iterator iterador = this.mCaja.listIterator();
    
    while( iterador.hasNext() ) {
    Caja c = (Caja) iterador.next();
        if (c.getDIdCaja()==id)
        {
            return c;}
        }
        return null;
    }

    // Metodo para comprobar si esa caja esta creada en la sucursal
    public boolean bbusquedaCajaSucursal(double id)
    {
        Iterator iterador = this.mCaja.listIterator();

        while( iterador.hasNext() ) {
            Caja c = (Caja) iterador.next();
            if (c.getDIdCaja()==id)
                {
                    return true;}
            }
        return false;
    }
    
    // Metodo que inicializa el saldo de una determinada caja de un empleado
    public void inicializaSaldo(double dimporte, double id, String stEmpleado)
    {
        Caja c = this.busquedaCajaSucursal(id);
        Empleado e = this.devuelveEmpleadosSucursal(stEmpleado);
        c.setDSaldo(dimporte); //Metemos el saldo
        c.setBEstadoCaja(true); //Ponemos la caja a verdad para que no se use
        e.setCajaEmpleado(c); //Le metemos al empleado la caja
        this.setEmpleadoActivo(e); // Ponemos el empleado activo.
    }
    
    // Metodo que nos devuelve el dinero que hay en la caja central
    public double saldoCajaCentral()
    {
        Caja c = this.busquedaCajaSucursal(0);
        return c.getDSaldo();
    }
    
    // Metodo que nos devuelve el dinero de una caja de un determinado empleado
    public double saldoCaja(String stEmpleado)
    {
        Empleado e = this.devuelveEmpleadosSucursal(stEmpleado);
        Caja c = e.getCajaEmpleado();
        return c.getDSaldo();
    }

    /*public void incrementoOPC(double dS)
    {
        OPC.setDSaldo(OPC.getDSaldo() + dS);
    }*/
    
    // Metodo que incrementa el dinero de una caja determinada
    public void incrementoCaja(double dS,double id)
    {
        Caja c = this.busquedaCajaSucursal(id);
        c.setDSaldo(c.getDSaldo()+dS);
        //this.decrementoCaja(dS,id);
    }

    /*public void decrementoOPC(double dS)
    {
    OPC.setDSaldo(OPC.getDSaldo() - dS);
    }*/
     
    // Metodo que decrementa el dinero de una caja determinada
    public void decrementoCaja(double dS, double id)
    {
        Caja c = this.busquedaCajaSucursal(id);
        c.setDSaldo(c.getDSaldo()-dS);
    }

    //Metodo que comprueba si la caja no esta cerrada, en caso de
    //que no este cerrada no la podemos usar, por lo que nos dice caja ocupada
    public boolean CajaOcupada(double id)
    {
        Caja c = this.busquedaCajaSucursal(id);
        return c.isBEstadoCaja();
    }

    //Metodo que cierra la caja cuando el usuario hace el arqueo o el parte de diferencias
    public void CerrarCajaOcupada(String stEmpleado)
    {
        Empleado e = this.devuelveEmpleadosSucursal(stEmpleado);
        Caja c = e.getCajaEmpleado();
        c.setBEstadoCaja(false);
        incrementoCaja(c.getDSaldo(),0); //Incremento Caja Central
        c.setDSaldo(c.getDSaldo()-c.getDSaldo()); //Decremento mi Caja
    }


    //Metodo que nos devuelve el id de la caja del empleado activo
    public double dameIdCaja()
    {
        Empleado e = this.getEmpleadoActivo();
        Caja c = e.getCajaEmpleado();
        return c.getDIdCaja();

    }

    
// ****************************************************************************
// ****************************************************************************
    
    
// ****************************************************************************
    
    // METODOS PARA LOS PARTES
    
// ****************************************************************************
    
    /**
     * @return the mParte
     */
    // Devolver Parte del ArrayList
    public ArrayList<ParteDiferencia> getMParte() {
        return mParte;
    }

    /**
     * @param mParte the mParte to set
     */
    
    // Anadir Parte al ArrayList
    public void setMParte(ArrayList<ParteDiferencia> mParte) {
        this.mParte = mParte;
    }

// Metodo para registrar un parte una vez que tenemos un descuadre en la caja    
public void RegistraParteDiferencia(double importe)
    {
        ParteDiferencia pParte = new ParteDiferencia();

        pParte.setDSaldo(importe);

        Date d = new Date();
        pParte.setDatOpe(d);

        this.IncrementarIdParte();
        pParte.setIdParte(this.idParte);

        pParte.setMEmpleado(this.getEmpleadoActivo());
        
        this.mParte.add(pParte);
    }

//Metodo para mostrar los partes por el arraylist del formulario jfrmParteDiferencia

// Para que salga los partes de un determinado usuario
//public String VerPartesDiferencias(String empleado)
public String VerPartesDiferencias(){
    String stAcu = "";

    //Cabecera

    Iterator iterador = this.mParte.listIterator();

        while( iterador.hasNext() ) {

            //Caja c = (Caja) iterador.next();
            //if (c.getDIdCaja()==id)
            ParteDiferencia p = (ParteDiferencia) iterador.next();

            //if(p.getdniEmpleado()==empleado)
            //{
                stAcu += "              ";
                stAcu += p.getdniEmpleado();
                stAcu += "              ";
                stAcu += p.getDatOpe();
                stAcu += "              ";
                stAcu += p.getDSaldo();
                stAcu += "              \n";
            //}
            
            
            
            }

    return stAcu;
}

//Metodo incrementar id de parte para luego poderlo usar desde el main
public double IncrementarIdParte()
{
    return this.idParte++;
}

// ****************************************************************************
// ****************************************************************************

// ****************************************************************************

    // METODOS PARA LA GESTION DE LAS DOMICILIACIONES

// ****************************************************************************

    private boolean bExisteDomiciliacion(String numCta, String nombreOrdenante) {
        
        boolean bRes = false;
        boolean bStop = false;
        
        Iterator iterador = this.mCliente.listIterator();


        while( iterador.hasNext() && !bRes && !bStop)
        {
            Cliente c = (Cliente) iterador.next();
            
            if(c.bPerteneceProducto(numCta))
            {
                bStop = true;
                
                bRes = c.bExisteDomiciliacion(nombreOrdenante);
            }
        }
        
        return bRes;
    }

    private Domiciliacion dameDomiciliacion(String numCta, String nombreOrdenante) {
        Iterator iterador = this.mCliente.listIterator();
        boolean bStop = false;

        while( iterador.hasNext() && !bStop)
        {
            Cliente c = (Cliente) iterador.next();
            
            if(c.bPerteneceProducto(numCta))
            {
                bStop = true;
                
                List<Domiciliacion> arrD = c.getMDomiciliacion();
                
                iterador = arrD.listIterator();
                
                while( iterador.hasNext())
                {
                    Domiciliacion d = (Domiciliacion) iterador.next();
                    
                    if(nombreOrdenante.compareTo(d.getStOrdenante()) == 0)
                    {
                        return d;
                    }
                }
                
            }
        }

        return null;
    }

    private void incluyeDomiciliacion(String numCta, Domiciliacion d) {
        boolean bStop = false;

        Iterator iterador = this.mCliente.listIterator();

        while( iterador.hasNext() && !bStop)
        {
            Cliente c = (Cliente) iterador.next();

            if(c.bPerteneceProducto(numCta))
            {
                bStop = true;
                c.addDomiciliacion(d);
            }
        }
    }

    public Cliente devuelveCliente(String numCta) {
        boolean bStop = false;

        Iterator iterador = this.mCliente.listIterator();
        Cliente c = null;

        while( iterador.hasNext() && !bStop)
        {
            c = (Cliente) iterador.next();

            if(c.bPerteneceProducto(numCta))
            {
                bStop = true;
            }
        }
        return c;
    }

// ****************************************************************************
// ****************************************************************************

// ****************************************************************************
    
    // METODOS PARA LA GESTION DE ERRORES DE LA REMESA
    
// ****************************************************************************
    
    // Metodo que devuelve true si la cuenta existe
     public boolean bExisteCuenta(String stCuenta)
    {
        Iterator iterador = this.mProducto.listIterator();

        while( iterador.hasNext() ) {
            Producto p = (Producto) iterador.next();
            if (p.getStNumPro().compareToIgnoreCase(stCuenta)==0)
                {
                    return true;}
            }
        return false;
    }
     
     public void GestionErroresRemesas(int numero)
     {
         if(numero==1)
         {  this.setMensaje("ERROR. Cuenta inexistente");}
         if(numero==2)
         {  this.setMensaje("ERROR. Cuenta origen saldo insuficiente");}
         if(numero==3)
         {  this.setMensaje("Remesa creada correctamente");}
         
     }

    /**
     * @return the mensaje
     */
    public String getMensaje() {
        return mensaje;
    }

    /**
     * @param mensaje the mensaje to set
     */
    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }
    
    
// ****************************************************************************
// Metodo para generar la remesa saliente;



    public void almacenaT_Externa(T_Externa te)
    {
        this.mT_Externa.add(te);
    }

    public String generarRemesaSaliente(String path)
    {
        FileWriter fw = null;
        String stRemesa = "";
        String stLinea = "";
        String stCodOrdenante = " 12344321X";
        String stCCOrdenante = "12345678900987654321";
        
        try {
            
            fw = new FileWriter(path);
            BufferedWriter  bf = new BufferedWriter(fw);

            double dImpT = 0;
            int iCant = 0;

            stLinea+="0356" + stCodOrdenante + "            001";

            Calendar c = Calendar.getInstance();
            String dia;
            String mes;
            String ano;

            dia = Integer.toString(c.get(Calendar.DATE));
            mes = Integer.toString(c.get(Calendar.MONTH)+1);
            ano = Integer.toString(c.get(Calendar.YEAR));

            if(dia.length() == 1){dia = "0" + dia;}
            if(mes.length() == 1){mes = "0" + mes;}
            ano = ano.substring(2, 4);
            stLinea+= dia + mes + ano + dia + mes + ano;

            stLinea += stCCOrdenante.substring(0, 8);
            stLinea += stCCOrdenante.substring(10, 20);
            stLinea += "1   ";
            stLinea += stCCOrdenante.substring(8, 10);

            while(stLinea.length() < 72)
            {stLinea+= " ";}
            stRemesa += stLinea + "\n";
            bf.write(stLinea);
            bf.newLine();
            stLinea = "";
            

            stLinea+="0356" + stCodOrdenante + "            002SWINDLERBANK E.S.";

            while(stLinea.length() < 72)
            {stLinea+= " ";}
            stRemesa += stLinea + "\n";
            bf.write(stLinea);
            bf.newLine();
            stLinea = "";

            stLinea+="0356" + stCodOrdenante + "            003C/MUSTAFA, 2";

            while(stLinea.length() < 72)
            {stLinea+= " ";}
            stRemesa += stLinea + "\n";
            bf.write(stLinea);
            bf.newLine();
            stLinea = "";

            stLinea+="0356" + stCodOrdenante + "            004HUELVA";

            while(stLinea.length() < 72)
            {stLinea+= " ";}
            stRemesa += stLinea + "\n";
            bf.write(stLinea);
            bf.newLine();
            stLinea = "";

            Iterator iterador = this.mT_Externa.listIterator();

            while( iterador.hasNext() )
            {
                T_Externa te = (T_Externa) iterador.next();

                String stBenef = "";

                stBenef+="0656" + stCodOrdenante + te.getStRemitente();

                while(stBenef.length() < 26) {stBenef+= " ";}
                if(stBenef.length() > 26) {stBenef= stBenef.substring(0, 26);}

                dImpT+= te.getDImporte() * (-1);
                iCant++;

                double dImp = te.getDImporte()*(-100);
                int iImp = (int) dImp;

                String stImp = Integer.toString(iImp);
                while(stImp.length() < 12) {stImp= "0" + stImp;}

                stLinea =   stBenef
                            + "010"
                            + stImp
                            + te.getStCCDestino().substring(0, 8)
                            + te.getStCCDestino().substring(10, 20)
                            + "11  "
                            + te.getStCCDestino().substring(8, 10);

                while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";

                stLinea =   stBenef
                            + "011";

                while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";

                stLinea =   stBenef
                            + "012";

                while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";

                stLinea =   stBenef
                            + "014";

                while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";

                stLinea =   stBenef
                            + "016"
                            + te.getStConcBreve();

                while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";
            }

            int iImpT = (int) dImpT;
            String stImpT = Integer.toString(iImpT);
            while(stImpT.length() < 12) {stImpT= "0" + stImpT;}

            String stCant = Integer.toString(iCant);
            while(stCant.length() < 8) {stCant= "0" + stCant;}

            stLinea+=   "0856" 
                        + stCodOrdenante 
                        + "               "
                        + stImpT
                        + stCant;

            while(stLinea.length() < 72)
                {stLinea+= " ";}
                stRemesa += stLinea + "\n";
                bf.write(stLinea);
                bf.newLine();
                stLinea = "";
                
            //bf.flush();
            bf.close();
        } catch (IOException ex) {
            Logger.getLogger(Sucursal.class.getName()).log(Level.SEVERE, null, ex);
        }

        return stRemesa;
    }
     

// ****************************************************************************
// ****************************************************************************
}