package com.rrhh.personal;

import com.contabilidad.EntConta.Permisosempleados;
import com.contabilidad.EntConta.Personal;
import com.contabilidad.EntConta.tipopermisos;
import com.contabilidad.EntConta.usuario;
import com.contabilidad.FacadeConta.PermisosempleadosFacadeLocal;
import com.contabilidad.FacadeConta.PersonalFacadeLocal;
import com.contabilidad.FacadeConta.tipopermisosFacadeLocal;
import com.cosmodas.EntCosmos.BitacorasWeb;
import com.cosmodas.EntCosmos.WcUsuarios;
import com.cosmodas.FacadeCosmos.BitacorasWebFacadeLocal;
import com.cosmodas.FacadeCosmos.WcUsuariosFacadeLocal;
import com.utilitarios.ConversorArchivosSO;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import org.apache.commons.io.FileUtils;
import org.primefaces.PrimeFaces;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.CroppedImage;
import org.primefaces.model.StreamedContent;

import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.bean.ViewScoped;
import javax.imageio.stream.FileImageOutputStream;
import javax.inject.Inject;
import javax.servlet.ServletContext;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

@ManagedBean(name = "permisosempleadosml")
@ViewScoped
public class permisosempleadosml implements Serializable {

    @Inject
    private Permisosempleados permisos, pemisosseleccion, permisosemp;

    private List<Permisosempleados> listapermisoseemp;
    private List<Permisosempleados> busquedapermisos;

    @Inject
    private Personal personal, personalseleccion;

    private List<Personal> listapersonal, emps;
    private List<Personal> busquedapersonal;

    @Inject
    private WcUsuarios usuarios;

    @Inject
    private tipopermisos tipopermiso, tipopermisoseleccion;

    private List<tipopermisos> listatipopermisos;

    private WcUsuarios usuario;
    private Date fechaIni;
    private Date fechaFin;
    //////////////////////////////////////////////////
    @EJB
    PermisosempleadosFacadeLocal permisosEfacadelocal;
    @EJB
    PersonalFacadeLocal personalfacadelocal;
    @EJB
    tipopermisosFacadeLocal tipopermisosfacadelocal;
    @EJB
    private BitacorasWebFacadeLocal bitacorasWebFacadeLocal;
    @EJB
    WcUsuariosFacadeLocal usuariofacadelocal;

    String mensaje="";
    private ExternalContext exc;
    private StreamedContent fotoEmpleado;
    private String imageTemp;
    private String realPaht;
    private CroppedImage cropeeDocumentos;
    private boolean botncliente=true;
    private JasperPrint jasperPrint;
    private String archiNuevoPdf;

    ///////////////////////////////////////////////////
    /// Cargamos los GET y SET de PermisosEmpleados ///
    public Permisosempleados getPermisos() {
        if(permisos == null){
            permisos = new Permisosempleados();
        }
        return permisos;
    }
    public void setPermisos(Permisosempleados permisos) { this.permisos = permisos; }
    public Permisosempleados getPemisosseleccion() { return pemisosseleccion;  }
    public void setPemisosseleccion(Permisosempleados pemisosseleccion) { this.pemisosseleccion = pemisosseleccion; }
    public Permisosempleados getPermisosemp() { return permisosemp; }
    public void setPermisosemp(Permisosempleados permisosemp) { this.permisosemp = permisosemp; }
    public List<Permisosempleados> getListapermisoseemp() { return listapermisoseemp; }
    public void setListapermisoseemp(List<Permisosempleados> listapermisoseemp) { this.listapermisoseemp = listapermisoseemp; }
    public List<Permisosempleados> getBusquedapermisos() { return busquedapermisos;  }
    public void setBusquedapermisos(List<Permisosempleados> busquedapermisos) { this.busquedapermisos = busquedapermisos;  }
    ////////////////////////////////////////////////////
    //////// Cargamos los Get y Set de Personal ////////
    public Personal getPersonal() {
        if(personal == null){
            personal = new Personal();
        }
        return personal;
    }
    public void setPersonal(Personal personal) { this.personal = personal; }
    public Personal getPersonalseleccion() { return personalseleccion; }
    public void setPersonalseleccion(Personal personalseleccion) { this.personalseleccion = personalseleccion; }
    public List<Personal> getListapersonal() { return listapersonal; }
    public void setListapersonal(List<Personal> listapersonal) { this.listapersonal = listapersonal; }
    public List<Personal> getBusquedapersonal() { return busquedapersonal; }
    public void setBusquedapersonal(List<Personal> busquedapersonal) { this.busquedapersonal = busquedapersonal; }
    public List<Personal> getEmps() { return emps;  }
    public void setEmps(List<Personal> emps) { this.emps = emps;  }
    ////////////////////////////////////////////////////
    public String getMensaje() { return mensaje; }
    public void setMensaje(String mensaje) { this.mensaje = mensaje; }
    public Date getFechaIni() { return fechaIni; }
    public void setFechaIni(Date fechaIni) { this.fechaIni = fechaIni; }
    public Date getFechaFin() { return fechaFin; }
    public void setFechaFin(Date fechaFin) { this.fechaFin = fechaFin; }
    ///////Cargamos los Get y Set de Usuarios ////////// W
    public WcUsuarios getUsuarios() { if(usuarios == null){ usuarios = new WcUsuarios(); }  return usuarios;  }
    public void setUsuarios(WcUsuarios usuario) { this.usuarios = usuario;  }

    public WcUsuarios getUsuario() {
        if(usuarios == null){
            usuarios = new WcUsuarios();
        }
        return usuario;
    }
    public void setUsuario(WcUsuarios usuario) { this.usuario = usuario;  }

    public ExternalContext getExc() { return exc; }
    public void setExc(ExternalContext exc) { this.exc = exc;  }
    public String getImageTemp() { return imageTemp;  }
    public void setImageTemp(String imageTemp) { this.imageTemp = imageTemp; }
    public String getRealPaht() { return realPaht; }
    public void setRealPaht(String realPaht) { this.realPaht = realPaht; }
    public CroppedImage getCropeeDocumentos() { return cropeeDocumentos; }
    public void setCropeeDocumentos(CroppedImage cropeeDocumentos) { this.cropeeDocumentos = cropeeDocumentos; }

    public StreamedContent getFotoEmpleado() { return fotoEmpleado; }
    public void setFotoEmpleado(StreamedContent fotoEmpleado) { this.fotoEmpleado = fotoEmpleado;  }
    ////////////// GET Y SET DE TIPOPERMISOS ////////////////
    public tipopermisos getTipopermiso() { return tipopermiso; }
    public void setTipopermiso(tipopermisos tipopermiso) { this.tipopermiso = tipopermiso;  }
    public tipopermisos getTipopermisoseleccion() { return tipopermisoseleccion; }
    public void setTipopermisoseleccion(tipopermisos tipopermisoseleccion) { this.tipopermisoseleccion = tipopermisoseleccion;  }
    public List<tipopermisos> getListatipopermisos() { return listatipopermisos; }
    public void setListatipopermisos(List<tipopermisos> listatipopermisos) { this.listatipopermisos = listatipopermisos; }

    public boolean isBotncliente() {  return botncliente; }
    public void setBotncliente(boolean botncliente) { this.botncliente = botncliente; }

    public JasperPrint getJasperPrint() { return jasperPrint; }
    public void setJasperPrint(JasperPrint jasperPrint) { this.jasperPrint = jasperPrint; }
    public String getArchiNuevoPdf() { return archiNuevoPdf; }
    public void setArchiNuevoPdf(String archiNuevoPdf) { this.archiNuevoPdf = archiNuevoPdf;  }
    //////////////////////////////////////////////////
    ///////////////////CONSTRUCTOR////////////////////
    @PostConstruct
    public void init() {
        this.listapermisoseemp = permisosEfacadelocal.findAll();
        this.listapersonal = personalfacadelocal.findAll();
        this.listatipopermisos = tipopermisosfacadelocal.findAll();
        exc = FacesContext.getCurrentInstance().getExternalContext();
        usuarios = (WcUsuarios) exc.getSessionMap().get("usuario");
        // ConversorArchivosSO co = new ConversorArchivosSO();
    }
    //// TOMA DE ID PERSONAL Y PERMISOS ///////////////
    public void idpermisos(Personal idpersonal){
        personal = idpersonal;
        System.out.println("Toma de id");
    }

    public void idpermisosEm(Permisosempleados idp){
        permisos = idp;
        System.out.println("ID permisos tomado");
    }
    /////////////////////////////////////////////////////
    public void crearPermisospersonal(Permisosempleados pep) throws Exception {
        ServletContext ctx = (ServletContext) FacesContext.getCurrentInstance()
                .getExternalContext().getContext();
        String realPath = ctx.getRealPath("/");
        String path = realPath + "dpermisos/";

        Personal p = getPersonal();
        try {
            if (Objects.isNull(pep.getIdpermisosempleados())) {
                int idbefugnis = 0;

                permisos.setCodigoEmpleado(personalseleccion.getCodigoEmpleado());
                permisos.setUsuarioCodigo(usuarios.getUsuarioCodigo());
                permisosEfacadelocal.create(permisos);

                pep = permisos;

                if (!Objects.isNull(realPaht)) {
                    File source = new File(realPaht);
                    File dest = new File("/opt/dpermisos/" + "DOC-" + permisos.getIdpermisosempleados() + ".jpg");
                    try {
                        FileUtils.copyFile(source, dest, false);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                addMessage(FacesMessage.SEVERITY_INFO, "Ingresado", permisos.getIdpermisosempleados() + " Documento Ingresado en sistema");
                PrimeFaces.current().executeScript("PF('permisosPML').hide();");

            }else {
                if (!Objects.isNull(realPaht)) {

                    File source = new File(realPaht);
                    File dest = new File("/opt/dpermisos/" + "DOC-" + permisos.getIdpermisosempleados() + ".jpg");
                    try {
                        FileUtils.copyFile(source, dest, false);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
                permisos = new Permisosempleados();
                this.personal = new Personal();
                this.listapermisoseemp = permisosEfacadelocal.findAll();
            }
            listapermisoseemp = permisosEfacadelocal.obtenerPermisosPorFecha(new Date(), new Date());
            System.out.println("Seguimiento en proceso");
            this.mensaje = "PERMISO CREADO CON EXITO";
            FacesMessage mscrea = new FacesMessage(mensaje);
            FacesContext.getCurrentInstance().addMessage(null, mscrea);
        }catch (Exception e){
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_FATAL, "Aviso", "Error al guardar"));
        }

        System.out.println(permisos.toString());
    }
    //////////////////  Validaciones /////////////////////////////////
    public void validaidpermisos(Permisosempleados idpe){
        FacesMessage mensage;
        if(idpe.getIdpermisosempleados() == null){
            this.permisosemp = idpe;
            PrimeFaces current = PrimeFaces.current();
            current.executeScript("PF('neueErlaubnis').show()");
            mensage = new FacesMessage(FacesMessage.SEVERITY_INFO, "DOCUMENTO", "AGREGAR EL DOCUMENTO PERMISO EN IMAGEN");
        }else{
            PrimeFaces current = PrimeFaces.current();
            current.executeScript("PF('permisosPML').hide()");
        }
    }
    /////////// TOMA ID DE GESTIONCONSULTOR Y LUEGO ELIMINA DATOS /////////////
    public void eliminaIDPermisos(Permisosempleados deletep) {
        this.permisos = deletep;
    }
    public void eliminaPermisoEmpleado(Permisosempleados elinapermiso) {
        this.permisosEfacadelocal.remove(elinapermiso);
        System.out.println("Permiso a Borrar");
        this.mensaje = "Proceso de Permiso Borrado";
        FacesMessage msbor = new FacesMessage(mensaje);
        FacesContext.getCurrentInstance().addMessage(null, msbor);
    }
    ////////////////////////////////////////////////////
    //****** Obtener los permisos  ***** //
    public void obternerPermisos(){
        listapermisoseemp = permisosEfacadelocal.obtenerPermisosPorFecha(fechaIni, fechaFin);
    }
    //////////////////////////////////////////////////
    public Personal obtenerEmpleado(String codemp){
        Personal rs = new Personal();
        rs = personalfacadelocal.find(codemp);
        return rs;
    }

    public List<Personal> complete(String query) {
        List<Personal> q = new ArrayList<>();
        q = personalfacadelocal.listNombreLike(query);
        emps = q;
        return q;
    }

    public void select(){
        System.out.println("alles gut");
    }

    public usuario obtenerUsuario(String usu){
        usuario rs = new usuario();
        //rs = permisosEfacadelocal.find(usu);
        return rs;
    }
    //// Seleccionar el personal donde cargara el permiso //////
    public void setSelectEmpleado(Permisosempleados p) {
        ConversorArchivosSO co = new ConversorArchivosSO();
        try {

            this.fotoEmpleado = co.datosPermisos("DOC-" + p.getIdpermisosempleados() + ".jpg");
            //   System.out.println(fotoEmpleado);
        } catch (Exception e) {
            this.fotoEmpleado = co.datosPermisos("default.jpg");
        }
        //System.out.println("verificando"+fotoEmpleado);
        this.permisos = p;
    }
    /////////////////////////////////////////////////////////////
    //************* Cargar Foto para Permisos ********************//
    public void guardarDocumentPermiso() {
        String path = FacesContext.getCurrentInstance().getExternalContext().getRealPath("/dpermisos/");
        String archivo = path + File.separator + getImageTemp();
        realPaht = archivo;
        String nameFotof = getImageTemp();
        String rutadepicture = path + File.separator;

        try {
            if (cropeeDocumentos != null) {
                FileImageOutputStream imageOutput = new FileImageOutputStream(new File(archivo));
                imageOutput.write(cropeeDocumentos.getBytes(), 0, cropeeDocumentos.getBytes().length);
                imageOutput.close();
            } else {
                OutputStream outStream = new FileOutputStream(new File(archivo));
                InputStream inputStream = new FileInputStream(path + "/temp/" + this.getImageTemp());
                byte[] buffer = new byte[6124];
                int bulk;
                while (true) {
                    bulk = inputStream.read(buffer);
                    if (bulk < 0) {
                        break;
                    }
                    outStream.write(buffer, 0, bulk);
                    outStream.flush();
                }
                outStream.close();
                inputStream.close();
            }
            actionPictures();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        ConversorArchivosSO co = new ConversorArchivosSO();
        this.fotoEmpleado = co.datosPermisos(rutadepicture, nameFotof);
        System.out.println(fotoEmpleado);
    }

    public void actionPictures() {
        this.cropeeDocumentos = null;
        this.imageTemp = null;
    }

    public void uploadFile(FileUploadEvent event) {
        try {

            ServletContext ctx = (ServletContext) FacesContext.getCurrentInstance()
                    .getExternalContext().getContext();
            String realPath = ctx.getRealPath("/");
            String path = realPath + "dpermisos/temp/";

            File f = new File(path);

            if (f.mkdirs()) {
                System.out.println("Directory is created");
            } else {
                System.out.println("Directory cannot be created");
            }

            String archivo = path + File.separator + event.getFile().getFileName();

            FileOutputStream fileOutputStream = new FileOutputStream(archivo);
            byte[] buffer = new byte[6124];
            int bulk;
            InputStream inputStream = event.getFile().getInputstream();
            while (true) {
                bulk = inputStream.read(buffer);
                if (bulk < 0) {
                    break;
                }
                fileOutputStream.write(buffer, 0, bulk);
                fileOutputStream.flush();
            }
            fileOutputStream.close();
            inputStream.close();

            this.setImageTemp(event.getFile().getFileName());

        } catch (IOException e) {
            e.printStackTrace();
            FacesContext.getCurrentInstance().addMessage("", new FacesMessage(FacesMessage.SEVERITY_ERROR, "", "Error al subir el archivo"));
        }
    }
    //********* GUARDAR LOS DOCUMENTOS DE PERMISOS EN JPG O PNG **********//
    public void addMessage(FacesMessage.Severity severity, String summary, String detail) {
        FacesContext.getCurrentInstance().
                addMessage(null, new FacesMessage(severity, summary, detail));
    }

    public void sparenDocumentoPermisos(Personal ne, Permisosempleados pe) {
        pe.setCodigoEmpleado(ne.getCodigoEmpleado());
        ServletContext ctx = (ServletContext) FacesContext.getCurrentInstance()
                .getExternalContext().getContext();
        String realPath = ctx.getRealPath("/");
        String path = realPath + "dpermisos/";

        if (Objects.isNull(pe.getCodigoEmpleado())) {
            pe.setFecha(permisos.getFecha());
            pe.setIdpermisosempleados(permisos.getIdpermisosempleados());

            if (!Objects.isNull(realPaht)) {
                File source = new File(realPaht);
                File dest = new File("/opt/dpermisos/" + "DOC-" + pe.getIdpermisosempleados() +  ".jpg");
                try {
                    FileUtils.copyFile(source, dest, false);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            addMessage(FacesMessage.SEVERITY_INFO, "Ingresado", pe.getIdpermisosempleados() + "Permisos en sistema");
            PrimeFaces.current().executeScript("PF('neueErlaubnis').hide();");
        }  else {

            if (!Objects.isNull(realPaht)) {
                File source = new File(realPaht);
                File dest = new File("/opt/dpermisos/" + "DOC-" + pe.getIdpermisosempleados() + ".jpg");
                try {
                    FileUtils.copyFile(source, dest, false);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }

            permisosEfacadelocal.edit(pe);

            this.realPaht = new String();
            // this.personal = new Personal();
            this.listapersonal = personalfacadelocal.findAll();
            addMessage(FacesMessage.SEVERITY_INFO, "Editado", pe.getIdpermisosempleados() + "Editado!!");
            PrimeFaces.current().executeScript("PF('neueErlaubnis').hide();");
        }
    }
    ////****************************** REPORTE DE Permisos ***************************//////
    public void rpermisosE(Permisosempleados rpe) throws JRException {
        String nombreEp = rpe.getCodigoEmpleado() +" - "+ personalfacadelocal.find(rpe.getCodigoEmpleado()).getNombreEmpleado();
        String usuariop = usuariofacadelocal.find(rpe.getUsuarioCodigo()).getUsuarioNombre();
        rpe.setUsuarioCodigo(usuariop);
        rpe.setCodigoEmpleado(nombreEp);

        List<Permisosempleados> listaPermisosDc = new ArrayList<>();
        // List<Personal> listapersonapp = new ArrayList<>();

        listaPermisosDc.add(rpe);
        JRBeanCollectionDataSource beanCollectionDataSource = new JRBeanCollectionDataSource(listaPermisosDc);
        String reportPath = "/opt/reportesJasper/rpermisos.jrxml";
        JasperReport jasperReport = JasperCompileManager.compileReport(reportPath);
        Map pas = new HashMap();
        pas.put("departamento", "hola" );

        jasperPrint = JasperFillManager.fillReport(jasperReport, pas, beanCollectionDataSource);
    }

    public void PDFPermisosDocument(Permisosempleados p) throws JRException, IOException {
        rpermisosE(p);
        JasperExportManager.exportReportToPdfFile(jasperPrint, "/opt/permisosdoc/permisoD" + p.getIdpermisosempleados() + ".pdf");
        HttpServletResponse httpServletResponse
                = (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse();
    }

    public void openPermisosPDF(Permisosempleados pe) throws IOException, JRException {
        PDFPermisosDocument(pe);
        ServletContext ctx = (ServletContext) FacesContext.getCurrentInstance()
                .getExternalContext().getContext();
        String realPath = ctx.getRealPath("/");

        System.out.println("direccion = " + realPath);
        File source = new File("/opt/permisosdoc/permisoD" + pe.getIdpermisosempleados() + ".pdf");
        File dest = new File(realPath + "/apps/pdf/" +pe.getIdpermisosempleados() + ".pdf");
        archiNuevoPdf = "./pdf/" + pe.getIdpermisosempleados() + ".pdf";
        FileUtils.copyFile(source, dest, false);
    }
    //*************************************************************************//

    public permisosempleadosml() {

    }

}