/* 
* Copyright 2016 Agencia Estatal de Administración Tibutaria
*
* Licencia con arreglo a la EUPL, Versión 1.1 o –en cuanto
* sean aprobadas por la Comisión Europea– versiones
* posteriores de la EUPL (la «Licencia»);
* Solo podrá usarse esta obra si se respeta la Licencia.
* Puede obtenerse una copia de la Licencia en:
*  
* https://joinup.ec.europa.eu/software/page/eupl
*  
* Salvo cuando lo exija la legislación aplicable o se acuerde
* por escrito, el programa distribuido con arreglo a la
* Licencia se distribuye «TAL CUAL», SIN GARANTÍAS NI CONDICIONES
* DE NINGÚN TIPO, ni expresasni implícitas.
*
* Véase la Licencia en el idioma concreto que rige los permisos y 
* limitaciones que establece la Licencia.
*/ 

package administrador.datos;

import administrador.PanelServidor;
import administrador.utiles.Global;
import java.util.*;

public class MapaOperadores implements Iterable<MapaOperadores.RegistroOperador> {

    HashMap<String, RegistroOperador> mapa;
    PanelServidor miPanel;

    public MapaOperadores(PanelServidor panel) {
        mapa = new HashMap<>();
        miPanel = panel;
    }

    @Override
    public Iterator<RegistroOperador> iterator() {
        return mapa.values().iterator();
    }

    public void add(String codigo, String nombre, String capacidad, String favoritas, String suplencias, String centro) {
        RegistroOperador op = new RegistroOperador();
        op.codigo = codigo.toUpperCase();
        op.nombre = nombre;
        op.centro = centro;
        op.cargaCapacidadSinTipo(capacidad, favoritas);
        op.cargaSuplencias(suplencias);
        mapa.put(op.codigo, op);
    }

    public void graba(String reg) {
        try {
            String cs[] = Global.split(reg, '|');
            if (cs[4].equals("1")) {
                String favs = "";
                if (cs.length > 5) {
                    favs = cs[5];
                }
                String supl = "";
                if (cs.length > 6) {
                    supl = cs[6];
                }
                add(cs[1], cs[2], cs[3], favs, supl, cs[8]);
            }
        } catch (Exception exc) {
            System.out.println("Error al grabar registro de Operadores");
        }
    }

    public RegistroOperador get(String codigo) {
        RegistroOperador op = mapa.get(codigo);
        if (op == null) {
            op = mapa.get(codigo.toLowerCase());
        }
        return op;
    }

    public String getNombre(String codigo) {
        String nombre = null;
        try {
            nombre = mapa.get(codigo.toUpperCase()).nombre;
        } catch (Exception exc) {
        }
        if (nombre == null) {
            return "CÓDIGO no identificado";
        }
        return nombre;
    }

    public ArrayList<String> getCapacidades(String codigo) {
        RegistroOperador op = get(codigo);
        ArrayList<String> al = new ArrayList<>();
        if (op == null) {
            return al;
        }
        for (DatosCapacidad dc : op.capacidades.values()) {
            if (!dc.nombre.equals(" ") && dc.Actual) {
                al.add(dc.nombre);
            }
        }
        return al;
    }

    public String[] getSuplencias(String codigo) {
        RegistroOperador op = get(codigo);
        if (op == null) {
            return null;
        }
        String[] ret = new String[op.suplencias.size()];
        return op.suplencias.toArray(ret);
    }

    public RegistroOperador actualizaEstado(String codigo, String estado) {
        RegistroOperador op = mapa.get(codigo);
        if (op == null) {
            return null;
        }
        op.estado = estado;
        return op;
    }

    public void actualizaOperador(String msj) {
        String partes[] = Global.split(msj, '|');
        RegistroOperador op = get(partes[0]);
        if (op != null) {
            if (partes.length < 2) {
                op.borraCapacidades();
            } else {
                op.cargaCapacidad(partes[1]);
            }
            if (partes.length < 3) {
                op.borraSuplencias();
            } else {
                op.cargaSuplencias(partes[2]);
            }
        }
    }

    public class RegistroOperador implements Comparable<RegistroOperador> {

        public String codigo;
        public String nombre;
        public String estado = "0";
        public String centro = "";
        public HashMap<String, DatosCapacidad> capacidades = new HashMap<>();
        public HashSet<String> suplencias = new HashSet<>();

        public void borraCapacidades() {
            capacidades.clear();
        }

        public void borraSuplencias() {
            suplencias.clear();
        }

        boolean buscarEnArray(String[] arr, String val) {
            for (String arr1 : arr) {
                if (arr1.equals(val)) {
                    return true;
                }
            }
            return false;
        }

        public void cargaCapacidadSinTipo(String cap, String fav) {
            capacidades.clear();
            cap = cap.trim();
            if (cap.length() == 0) {
                return;
            }
            cap = cap.replace(',','-');
            String[] caps = Global.split(cap, '-');
            fav = fav.replace(',','-');
            String[] favs = Global.split(fav, '-');
            for (int i = 0; i < caps.length; i++) {
                caps[i] = caps[i].trim();
                if (caps[i].length() > 0) {
                    boolean esFav = false;
                    if (buscarEnArray(favs, caps[i])) {
                        esFav = true;
                    }
                    capacidades.put(caps[i], new DatosCapacidad(caps[i], true, true, false, esFav));
                }
            }
        }

        public void cargaSuplencias(String supl) {
            suplencias.clear();
            String[] caps = Global.split(supl, '-');
            for (int i = 0; i < caps.length; i++) {
                caps[i] = caps[i].trim();
                if (caps[i].length() > 0) {
                    suplencias.add(caps[i]);
                }
            }
        }

        public boolean esSuplente(String cola) {
            return suplencias.contains(cola);
        }

        public boolean tieneCapacidad(String cola) {
            return capacidades.containsKey(cola) && capacidades.get(cola).Actual;
        }

        public void cargaCapacidad(String cap) {
            capacidades.clear();
            String[] caps = Global.split(cap, '-');
            for (int i = 0; i < caps.length; i++) {
                caps[i] = caps[i].trim();
                if (caps[i].length() > 0) {
                    String ncap = caps[i].substring(0, caps[i].length() - 4).trim();
                    if (ncap.length() > 0) {
                        capacidades.put(ncap, new DatosCapacidad(caps[i]));
                    }
                }
            }
        }

        public void cargaCapacidad(DatosCapacidad dc, boolean suplente) {
            if (!dc.Permanente && !dc.Actual && !dc.DeMesa) {
                capacidades.remove(dc.nombre);
            } else {
                capacidades.put(dc.nombre, new DatosCapacidad(dc));
            }
            if (suplente) {
                suplencias.add(dc.nombre);
            } else {
                suplencias.remove(dc.nombre);
            }
        }

        @Override
        public int compareTo(RegistroOperador op) {
            return nombre.compareTo(op.nombre);
        }

        String cadenaCapacidad() {
            StringBuilder s = new StringBuilder();
            for (DatosCapacidad dc : capacidades.values()) {
                if (dc.nombre.trim().length() > 0) {
                    s.append(dc.toString()).append("-");
                }
            }
            if (s.length() > 0) {
                s.setLength(s.length() - 1);
            }
            return s.toString();
        }

        String cadenaSuplencias() {
            StringBuilder s = new StringBuilder();
            for (String cola : suplencias) {
                s.append(cola).append("-");
            }
            if (s.length() > 0) {
                s.setLength(s.length() - 1);
            }
            return s.toString();
        }

        public void enviarCapacidad() {
            miPanel.enviarCambioCapacidad(codigo, cadenaCapacidad(), cadenaSuplencias());
        }

        public boolean sinCapacidades() {
            return capacidades.isEmpty() && suplencias.isEmpty();
        }
    }
}
