/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.crov.prase.prase;

import com.arrebol.taxiservicios.beans.TaxiGenericBean;
import com.arrebol.taxiservicios.controller.admin.AdminSalesController;
import com.arrebol.taxiservicios.controller.admin.CustomerController;
import com.arrebol.taxiservicios.controller.admin.DriverController;
import com.arrebol.taxiservicios.controller.admin.GenericPersonController;
import com.arrebol.taxiservicios.controller.system.UserController;
import com.arrebol.taxiservicios.model.admin.Taxi;
import com.arrebol.taxiservicios.model.core.Address;
import com.arrebol.taxiservicios.model.core.Person;
import com.arrebol.taxiservicios.model.core.User;
import com.arrebol.taxiservicios.model.enums.BasicType;
import com.arrebol.taxiservicios.model.enums.PersonType;
import com.arrebol.taxiservicios.model.enums.Riesgo;
import com.crov.prase.controller.catalog.HospitalesController;
import com.crov.prase.controller.catalog.TipoSiniestroController;
import com.crov.prase.controller.prase.BucketController;
import com.crov.prase.controller.prase.IncidenceController;
import com.crov.prase.controller.prase.PolizaController;
import com.crov.prase.model.catalog.Hospitales;
import com.crov.prase.model.catalog.TipoSiniestro;
import com.crov.prase.model.prase.Incidence;
import com.crov.prase.model.prase.IncidenceDamage;
import com.crov.prase.model.prase.IncidenceOwnDriver;
import com.crov.prase.model.prase.IncidenceStory;
import com.crov.prase.model.prase.IncidenceThirdPartyVehicle;
import com.crov.prase.model.prase.Poliza;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.view.ViewScoped;
import javax.inject.Named;
import javax.servlet.http.HttpServletResponse;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.primefaces.model.UploadedFile;

/**
 *
 * @author Crov
 */
@Named("cargarIncidenciaBean")
@ViewScoped
public class CargarIncidenciaBean extends TaxiGenericBean implements Serializable {

    private static final long serialVersionUID = -136031528440947006L;
    final Logger logger = LogManager.getLogger(PolizaBean.class);

    private String idIncidence;

    private IncidenceController incidenceController;
    private CustomerController customerController;
    private AdminSalesController adminSalesController;
    private PolizaController polizaController;
    private HospitalesController hospitalesController;
    private GenericPersonController genericPersonController;
    private DriverController driverController;
    private UserController UserController;
    private TipoSiniestroController tipoSiniestroController;

    private int tabActive;
    private List<Person> listDrivers;
    private String selectDriver;
    private List<Taxi> listTaxis;
    private String selectTaxi;
    private List<Poliza> listPoliza;
    private String selectPoliza;
    private List<Incidence> listIncidence;
    private Incidence selectIncidence;
    private String description;
    private String type;
    private Boolean registroInicialCompleto;
    private Incidence newIncidence;
    private Boolean polizaSeleccinada;
    private List<User> listUsuarios;
    private String selectUsuario;
    private List<Person> drivers;
    private List<TipoSiniestro> tipoSiniestro;
    private String selectedDriver;
    private String selectedTipoSiniestro;
    private Person driver;
    private Date fechaActual;

    // Declaracion del siniestro 
    private Date fechaDeclaracion; //date_story
    private String lugarDeclaracion; //lugar
    private String coloniaDeclaracion; //colonia
    private String delegacionDeclaracion; //delegacion
    private String narracionAsegurado; //narracion_asegurado
    private String afectacionesVehiculoSocio; //afectaciones_vehiculo_socio    
    private Boolean registroDeclaracionCompleto;
    private IncidenceStory newIncidenceStory;

    // Descripción de vehículo del tercero
    // incidence_third_party_vehicle
    private String nombrePropietario; // nombre_propietario
    private String nombreConductor; // nombre_conductor
    private String direccion1; // direccion_1
    private String telefono1; // telefono_1
    private String direccion2; // direccion_2
    private String telefono2; // telefono_2
    private String numeroLicenciaVehicle; // numeroLicencia
    private String vehiculoMarcaTipo; //vehiculo_marca_tipo
    private String modelo; //modelo
    private String color; // color
    private String placas; // placas
    private String serie; // serie
    private String ciaSeguros; // cia_seguros
    private String poliza; // poliza
    private String cobertura; // cobertura
    private String deducible; // deducible
    private Date vencimiento; //vencimiento
    private String siniestro; // siniestro
    private String ajustador; // ajustador
    private String datosVehiculoTercero; // datos_vehiculo_tercero  
    private IncidenceThirdPartyVehicle newIncidenceThirdPartyVehicle;
    private Boolean registroIncidenceThirdPartyVehicleCompleto;
    private List<IncidenceThirdPartyVehicle> incidenceThirdPartyVehicle;

    // Descripción de vehículo del tercero (Conductor)
    // incidence_own_driver
    private String firstName;  // first_name
    private String secondName; // second_name
    private String lastName; // last_name
    private String middleName; // middle_name
    private String numeroLicenciaDriver; // numero_licencia
    private Date fechaAltaLicencia; // fecha_alta_licencia
    private Date fechaNacimiento; //fecha_nacimiento
    private String domicilio; // domicilio
    private String telefono; // telefono
    private IncidenceOwnDriver newIncidenceOwnDriver;
    private List<IncidenceOwnDriver> listIncidenceOwnDriver;

    // Lesiones y daños
    private String nombre; //nombre
    private String edad; //edad
    private String direccion; // direccion
    private String telefonoDamage; // telefono
    private String lesionesSufridad; //lesiones_sufridad
    private Boolean ambulancia; // ambulancia
    private Boolean paseMedico; //pase_medico
    private List<Hospitales> listHospitales;
    private String idHospital; //id_hospital
    private String riesgo; //riesgo
    private IncidenceDamage newIncidenceDamage;
    private List<IncidenceDamage> listIncidenceDamage;
    private String correo;//correo

    //Decisión del vehículo asociado
    private String marcaP;
    private String tipoP;
    private String modeloP;
    private String colorP;
    private String rutaP;
    private String placasP;
    private String numeroSerie;
    private String noMotor;

    // Datos de nuestro conductor
    private String nombreConductorP;
    private String noTipoLicenciaP;
    private String lugarFechaAltaP;
    private String domicilioConductorP;
    private String fechaNacimientoConductorP;
    private String telefonoConductorP;

    // Datos poliza
    private String nombreAsociadoP;
    private String estatusPolizaP;
    private String direccionP;

    private BucketController controladorBucket;
    private UploadedFile fileCredencialConductor;
    private UploadedFile fileCredencialConductorTercero;
    private String linkLocal;
    private String linkImg;

    private String edChPrimerNombre;
    private String edChSegundoNombre;
    private String edChPrimerApellido;
    private String edChSegundoApellido;
    private String edChLicencia;
    private String edChCalle;
    private String edChLocalidad;
    private String edChRegion;
    private Date edChFechaNacimiento;
    private String edChTelefono;

    @PostConstruct
    public void init() {
        logger.info("init");
        try {
            loadTaxiPropertyFile();
            loadBundlePropertyFile();
            setControladorBucket(new BucketController());
            setPolizaController(new PolizaController());
            setCustomerController(new CustomerController());
            setAdminSalesController(new AdminSalesController());
            setIncidenceController(new IncidenceController());
            setHospitalesController(new HospitalesController());
            setDriverController(new DriverController());
            setUserController(new UserController());
            setTipoSiniestroController(new TipoSiniestroController());
            setIdIncidence(externalContext().getRequestParameterMap().get("incidence"));
            setRegistroInicialCompleto(true);
            setRiesgo("Conductor");
            setFechaActual(new Date());

            setLinkLocal(getBundleTaxiFile().getString("outcome.prase.cargarIncidencia") + ".jsf?incidence=" + externalContext().getRequestParameterMap().get("incidence"));

            setListDrivers(getAdminSalesController().getAllDrivers());
            setListTaxis(getCustomerController().fillTaxisComboBox());
            setListPoliza(getPolizaController().findActive(getLoggedUser().getLocation()));
            setListIncidence(getIncidenceController().fillIncidenceByLocation(getLoggedUser().getLocation()));
            setListHospitales(getHospitalesController().findHospitales());
            setListUsuarios(getUserController().findUserActivesAndAjustador(getLoggedUser().getLocation().getId()));
            setDrivers(getDriverController().getAllPersonsByPersonTye(PersonType.DRIVER));
            setTipoSiniestro(getTipoSiniestroController().findTipoSiniestro());

            Incidence incidence = getIncidenceController().findIncidence(getIdIncidence());
            setNewIncidence(incidence);
            setDriver(incidence.getDriver());
            setSelectUsuario(incidence.getAjustador() != null ? incidence.getAjustador().getId() : null);
            // secargan los datos la porliza seleccinada en el regitro 
            setSelectPoliza(incidence.getPoliza().getId());
            cargarDatosPoliza();
            cargarDatosDriver();
            setRegistroInicialCompleto(true);

            IncidenceStory declaracionSiniestro = getIncidenceController().findIncidenceStoryByIncidence(incidence);
            if (declaracionSiniestro == null) {
                setRegistroDeclaracionCompleto(false);
                setNewIncidenceStory(new IncidenceStory());
            } else {
                setRegistroDeclaracionCompleto(true);
                setNewIncidenceStory(declaracionSiniestro);
            }

            /*IncidenceThirdPartyVehicle thirdPartyVehicle = getIncidenceController().findIncidenceThirdPartyVehicleByIncidence(incidence);
            if (thirdPartyVehicle == null) {
                setRegistroIncidenceThirdPartyVehicleCompleto(false);
                setNewIncidenceThirdPartyVehicle(new IncidenceThirdPartyVehicle());
            } else {
                setRegistroIncidenceThirdPartyVehicleCompleto(true);
                setNewIncidenceThirdPartyVehicle(thirdPartyVehicle);
            }*/
            setIncidenceThirdPartyVehicle(getIncidenceController().findListIncidenceThirdPartyVehicleByIncidence(incidence));

            setListIncidenceOwnDriver(getIncidenceController().findAllIncidenceOwnDriverByIncidence(getNewIncidence()));
            setListIncidenceDamage(getIncidenceController().findAllIncidenceDamageByIncidence(getNewIncidence()));

            setLinkImg("https://crov-inmobiliaria.s3.us-east-2.amazonaws.com/");

        } catch (Exception e) {
            logger.error(e);
        }
    }

    public void cargarDatosPoliza() {
        try {
            Poliza pol = getPolizaController().findPoliza(getSelectPoliza());
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MMM-dd");
            //Decisión del vehículo asociado
            setMarcaP(pol.getTaxi().getVehicle().getName());
            setTipoP(pol.getTaxi().getVehicle().getBrand().getName());
            setModeloP(pol.getTaxi().getYear());
            setColorP(pol.getTaxi().getColor().getName());
            setRutaP("");
            setPlacasP(pol.getTaxi().getPlaca());
            setNumeroSerie(pol.getTaxi().getSerialNumber());
            setNoMotor(pol.getTaxi().getMotorNmumber());

            // Datos poliza
            String segundoNombre = (pol.getCustomer().getSecondName().equals("") || pol.getCustomer() == null) ? "" : " " + pol.getCustomer().getSecondName();
            setNombreAsociadoP(pol.getCustomer().getFirstName() + segundoNombre + " " + pol.getCustomer().getLastName() + " " + pol.getCustomer().getMiddleName());
            setEstatusPolizaP(pol.getEstatus().getValue());

            Address addressCustomer = getPolizaController().findAddress(pol.getTaxi().getCustomer().getId());
            setDireccionP(addressCustomer != null ? addressCustomer.getStreet() + " " + addressCustomer.getExtendedAddress() + " " + addressCustomer.getLocality() + " " + addressCustomer.getRegion() : "N/A");

            setSelectedTipoSiniestro(getNewIncidence().getType().getId());

            setPolizaSeleccinada(true);
        } catch (Exception e) {
            logger.error("Error al cargar los datos de la poliza");
        }
    }

    public void cargarDatosDriver() {
        logger.info("Method cargarDatosDriver");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MMM-dd");

        setNombreConductorP(driver.getFirstName() + " " + driver.getSecondName() + " " + driver.getLastName() + " " + driver.getMiddleName());
        setNoTipoLicenciaP(driver.getLicense());
        setLugarFechaAltaP(sdf.format(driver.getCreatedOn()) + " " + driver.getLocation().getCompleteAddress());
        setDomicilioConductorP(driver.getDireccion());
        setFechaNacimientoConductorP(driver.getBirthdate().toString());
        setTelefonoConductorP(driver.getTelefono());

    }

    public void updateIncidence() {
        logger.info("updateIncidence");
        try {
            // Nueva incidencia                        
            Poliza pol = getPolizaController().findPoliza(getSelectPoliza());
            getNewIncidence().setPoliza(pol);
            getNewIncidence().setDriver(getDriver());
            getNewIncidence().setTaxi(pol.getTaxi());
            getNewIncidence().setAjustador(new User(getSelectUsuario(), ""));
            
            if (!getFileCredencialConductor().getFileName().isEmpty()) {
                String nombreDocumentoNuevo = getFileCredencialConductor().getFileName();
                String[] formato = nombreDocumentoNuevo.split("\\.", 2);
                getNewIncidence().setImgCredencial("credencialConductor." + formato[1]);
            }
            
            getIncidenceController().addIncidence(getNewIncidence(), getLoggedUser(), false);
            // Se valida si se seleccionó una foto de la credencial             
            if (!getFileCredencialConductor().getFileName().isEmpty()) {
                cargarDocumento(getFileCredencialConductor(), "credencialConductor", getNewIncidence().getId(), getLinkLocal());
            }
            //Actualización de la lista  
            setListIncidence(getIncidenceController().fillIncidenceByLocation(getLoggedUser().getLocation()));
            //Reseteo de datos de guardado
            if (getNewIncidence().getId() != null) {
                setRegistroInicialCompleto(true);
            } else {
                setRegistroInicialCompleto(false);
            }
            logger.info("Reporte principal actualizado");
            showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Reporte principal actualizado correctamente");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar actualizar el reporte principal");
            logger.error("updateIncidence() " + e);
        }
    }

    public void guardarDeclaracionSiniestro() {
        logger.info("guardarDeclaracionSiniestro");
        try {
            if (getNewIncidence().getId() != null) {
                IncidenceStory declaracionSiniestro = new IncidenceStory();
                declaracionSiniestro.setIncidence(getNewIncidence());
                declaracionSiniestro.setDateStory(getNewIncidenceStory().getDateStory());
                declaracionSiniestro.setLugar(getNewIncidenceStory().getLugar());
                declaracionSiniestro.setColonia(getNewIncidenceStory().getColonia());
                declaracionSiniestro.setDelegacion(getNewIncidenceStory().getDelegacion());
                declaracionSiniestro.setNarracionAsegurado(getNewIncidenceStory().getNarracionAsegurado());
                declaracionSiniestro.setAfectacionesVehiculoSocio(getNewIncidenceStory().getAfectacionesVehiculoSocio());
                getIncidenceController().addIncidenceStory(declaracionSiniestro, getLoggedUser(), true);
                setNewIncidenceStory(declaracionSiniestro);
                setRegistroDeclaracionCompleto(true);
                showMessage(FacesMessage.SEVERITY_INFO, "Guardado con éxito", "Declaración del siniestro guardado con éxito");
                logger.info("Declaración del siniestro guardado con éxito");
            } else {
                showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de vincular el reporte principal");
                logger.error("Ocurrió un error al tratar de vincular el reporte principal");
            }

        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar guardar la declaración del siniestro");
            logger.error("guardarDeclaracionSiniestro() " + e);
        }
    }

    public void actualizarDeclaracionSiniestro() {
        logger.info("actualizarDeclaracionSiniestro");
        try {
            getIncidenceController().addIncidenceStory(getNewIncidenceStory(), getLoggedUser(), false);
            showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Declaración del siniestro se actualizo correctamente");
            logger.info("Declaración del siniestro realizada con éxito");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar actualizar la declaración del siniestro");
            logger.error("actualizarDeclaracionSiniestro() " + e);
        }
    }

    public void guardarVehículoTercero() {
        logger.info("guardarVehículoTercero");
        if (getNewIncidence().getId() != null) {
            IncidenceThirdPartyVehicle thirdPartyVehicle = new IncidenceThirdPartyVehicle();
            thirdPartyVehicle.setIncidence(getNewIncidence());
            thirdPartyVehicle.setNombrePropietario(getNombrePropietario());
            thirdPartyVehicle.setNombreConductor(getNombreConductor());
            thirdPartyVehicle.setDireccion1(getDireccion1());
            thirdPartyVehicle.setTelefono1(getTelefono1());
            thirdPartyVehicle.setDireccion2(getDireccion2());
            thirdPartyVehicle.setTelefono2(getTelefono2());
            thirdPartyVehicle.setNumeroLicencia(getNumeroLicenciaVehicle());
            thirdPartyVehicle.setVehiculoMarcaTipo(getVehiculoMarcaTipo());
            thirdPartyVehicle.setModelo(getModelo());
            thirdPartyVehicle.setColor(getColor());
            thirdPartyVehicle.setPlacas(getPlacas());
            thirdPartyVehicle.setSerie(getSerie());
            thirdPartyVehicle.setCiaSeguros(getCiaSeguros());
            thirdPartyVehicle.setPoliza(getPoliza());
            thirdPartyVehicle.setCobertura(getCobertura());
            thirdPartyVehicle.setDeducible(getDeducible());
            thirdPartyVehicle.setVencimiento(getVencimiento());
            thirdPartyVehicle.setSiniestro(getSiniestro());
            thirdPartyVehicle.setAjustador(getAjustador());
            thirdPartyVehicle.setDatosVehiculoTercero(getDatosVehiculoTercero());
            // Se valida si se seleccionó una foto de la credencial 
            /*if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
            String nombreDocumentoNuevo = getFileCredencialConductorTercero().getFileName();
            String[] formato = nombreDocumentoNuevo.split("\\.", 2);
            thirdPartyVehicle.setImgCredencial("credencialConductorTercero." + formato[1]);
            }*/
            getIncidenceController().addIncidenceThirdPartyVehicle(thirdPartyVehicle, getLoggedUser(), true);
            resetVehiculoTercero();
            setIncidenceThirdPartyVehicle(getIncidenceController().findListIncidenceThirdPartyVehicleByIncidence(getNewIncidence()));

            // Se valida si se seleccionó una foto de la credencial 
            /*if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
            cargarDocumento(getFileCredencialConductorTercero(), "credencialConductorTercero", thirdPartyVehicle.getId(), getLinkLocal());
            }*/
            setRegistroIncidenceThirdPartyVehicleCompleto(true);
            showMessage(FacesMessage.SEVERITY_INFO, "Guardado con éxito", "Descripción de vehículo del tercero guardado con éxito");
            logger.info("Descripción de vehículo del tercero guardado con éxito");
        } else {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de vincular el reporte principal");
            logger.error("Ocurrió un error al tratar de vincular el reporte principal");
        }
    }

    public void actualizarVehículoTercero() {
        logger.info("actualizarVehículoTercero");
        // Se valida si se seleccionó una foto de la credencial 
        /*if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
        String nombreDocumentoNuevo = getFileCredencialConductorTercero().getFileName();
        String[] formato = nombreDocumentoNuevo.split("\\.", 2);
        getNewIncidenceThirdPartyVehicle().setImgCredencial("credencialConductorTercero." + formato[1]);
        }*/

        getNewIncidenceThirdPartyVehicle().setNombrePropietario(getNombrePropietario());
        getNewIncidenceThirdPartyVehicle().setNombreConductor(getNombreConductor());
        getNewIncidenceThirdPartyVehicle().setDireccion1(getDireccion1());
        getNewIncidenceThirdPartyVehicle().setTelefono1(getTelefono1());
        getNewIncidenceThirdPartyVehicle().setDireccion2(getDireccion2());
        getNewIncidenceThirdPartyVehicle().setTelefono2(getTelefono2());
        getNewIncidenceThirdPartyVehicle().setNumeroLicencia(getNumeroLicenciaVehicle());
        getNewIncidenceThirdPartyVehicle().setVehiculoMarcaTipo(getVehiculoMarcaTipo());
        getNewIncidenceThirdPartyVehicle().setModelo(getModelo());
        getNewIncidenceThirdPartyVehicle().setColor(getColor());
        getNewIncidenceThirdPartyVehicle().setPlacas(getPlacas());
        getNewIncidenceThirdPartyVehicle().setSerie(getSerie());
        getNewIncidenceThirdPartyVehicle().setCiaSeguros(getCiaSeguros());
        getNewIncidenceThirdPartyVehicle().setPoliza(getPoliza());
        getNewIncidenceThirdPartyVehicle().setCobertura(getCobertura());
        getNewIncidenceThirdPartyVehicle().setDeducible(getDeducible());
        getNewIncidenceThirdPartyVehicle().setVencimiento(getVencimiento());
        getNewIncidenceThirdPartyVehicle().setSiniestro(getSiniestro());
        getNewIncidenceThirdPartyVehicle().setAjustador(getAjustador());
        getNewIncidenceThirdPartyVehicle().setDatosVehiculoTercero(getDatosVehiculoTercero());
        getIncidenceController().addIncidenceThirdPartyVehicle(getNewIncidenceThirdPartyVehicle(), getLoggedUser(), false);
        // Se valida si se seleccionó una foto de la credencial 
        /*if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
        cargarDocumento(getFileCredencialConductorTercero(), "credencialConductorTercero", getNewIncidenceThirdPartyVehicle().getId(), getLinkLocal());
        }*/
        showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Descripción de vehículo del tercero actualizada con éxito");
        logger.info("Descripción de vehículo del tercero actualizada con éxito");
    }

    public void actualizarCredencialVehículoTercero() {
        logger.info("actualizarVehículoTercero");
        // Se valida si se seleccionó una foto de la credencial 
        
        
        try {
            if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
                String nombreDocumentoNuevo = getFileCredencialConductorTercero().getFileName();
                String[] formato = nombreDocumentoNuevo.split("\\.", 2);
                getNewIncidenceThirdPartyVehicle().setImgCredencial("credencialConductorTercero." + formato[1]);
            }

            getIncidenceController().addIncidenceThirdPartyVehicle(getNewIncidenceThirdPartyVehicle(), getLoggedUser(), false);
            // Se valida si se seleccionó una foto de la credencial 
            if (!getFileCredencialConductorTercero().getFileName().isEmpty()) {
                cargarDocumento(getFileCredencialConductorTercero(), "credencialConductorTercero", getNewIncidenceThirdPartyVehicle().getId(), getLinkLocal());
            }
            showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Descripción de vehículo del tercero actualizada con éxito");
            logger.info("Descripción de vehículo del tercero actualizada con éxito");
        } catch (IOException ex) {
        }
    }

    public void guardarVehículoTerceroConductor() {
        logger.info("guardarVehículoTerceroConductor");
        try {
            if (getNewIncidence().getId() != null) {
                IncidenceOwnDriver ownDriver = new IncidenceOwnDriver();
                ownDriver.setIncidence(getNewIncidence());
                ownDriver.setFirstName(getFirstName());
                ownDriver.setLastName(getLastName());
                ownDriver.setSecondName(getSecondName());
                ownDriver.setMiddleName(getMiddleName());
                ownDriver.setNumeroLicencia(getNumeroLicenciaDriver());
                ownDriver.setFechaAltaLicencia(getFechaAltaLicencia());
                ownDriver.setFechaNacimiento(getFechaNacimiento());
                ownDriver.setDomicilio(getDomicilio());
                ownDriver.setTelefono(getTelefono());
                getIncidenceController().addIncidenceOwnDriver(ownDriver, getLoggedUser(), true);
                getListIncidenceOwnDriver().add(ownDriver);
                resetVehiculoTercero();
                showMessage(FacesMessage.SEVERITY_INFO, "Guardado con éxito", "Descripción de vehículo del tercero guardado con éxito");
                logger.info("Descripción de vehículo del tercero guardado con éxito");
            } else {
                showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de vincular el reporte principal");
                logger.error("Ocurrió un error al tratar de vincular el reporte principal");
            }
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar guardar la descripción de vehículo del tercero");
            logger.error("guardarVehículoTerceroConductor() " + e);
        }
    }

    public void actualizarVehículoTerceroConductor() {
        logger.info("actualizarVehículoTerceroConductor");
        try {
            getNewIncidenceOwnDriver().setFirstName(getFirstName());
            getNewIncidenceOwnDriver().setSecondName(getSecondName());
            getNewIncidenceOwnDriver().setLastName(getLastName());
            getNewIncidenceOwnDriver().setMiddleName(getMiddleName());
            getNewIncidenceOwnDriver().setNumeroLicencia(getNumeroLicenciaDriver());
            getNewIncidenceOwnDriver().setFechaAltaLicencia(getFechaAltaLicencia());
            getNewIncidenceOwnDriver().setFechaNacimiento(getFechaNacimiento());
            getNewIncidenceOwnDriver().setDomicilio(getDomicilio());
            getNewIncidenceOwnDriver().setTelefono(getTelefono());
            getIncidenceController().addIncidenceOwnDriver(getNewIncidenceOwnDriver(), getLoggedUser(), false);
            setListIncidenceOwnDriver(getIncidenceController().findAllIncidenceOwnDriverByIncidence(getNewIncidence()));
            resetVehiculoTercero();
            showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Descripción de vehículo del tercero (conductor) actualizado con éxito");
            logger.info("Descripción de vehículo del tercero (conductor) actualización con éxito");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar actualizar la descripción de vehículo del tercero (conductor)");
            logger.error("actualizarVehículoTerceroConductor() " + e);
        }
    }

    public void resetConductor() {
        logger.info("resetVehiculoTercero");
        setNewIncidenceOwnDriver(null);
        setFirstName("");
        setSecondName("");
        setLastName("");
        setMiddleName("");
        setNumeroLicenciaDriver("");
        setFechaAltaLicencia(null);
        setFechaNacimiento(null);
        setDomicilio("");
        setTelefono("");
    }

    public void resetVehiculoTercero() {
        logger.info("resetVehiculoTercero");
        setRegistroIncidenceThirdPartyVehicleCompleto(false);

        setNewIncidenceThirdPartyVehicle(null);
        setNombrePropietario("");
        setNombreConductor("");
        setDireccion1("");
        setTelefono1("");
        setDireccion2("");
        setTelefono2("");
        setNumeroLicenciaVehicle("");
        setVehiculoMarcaTipo("");
        setModelo("");
        setPlacas("");
        setSerie("");
        setCiaSeguros("");
        setPoliza("");
        setCobertura("");
        setDeducible("");
        setVencimiento(null);
        setSiniestro("");
        setAjustador("");
        setDatosVehiculoTercero("");

    }

    public void cargarConductor() {
        logger.info("Cargando datos VehiculoTercero (Incidence Own Driver)");
        try {
            setFirstName(getNewIncidenceOwnDriver().getFirstName());
            setSecondName(getNewIncidenceOwnDriver().getSecondName());
            setLastName(getNewIncidenceOwnDriver().getLastName());
            setMiddleName(getNewIncidenceOwnDriver().getMiddleName());
            setNumeroLicenciaDriver(getNewIncidenceOwnDriver().getNumeroLicencia());
            setFechaAltaLicencia(getNewIncidenceOwnDriver().getFechaAltaLicencia());
            setFechaNacimiento(getNewIncidenceOwnDriver().getFechaNacimiento());
            setDomicilio(getNewIncidenceOwnDriver().getDomicilio());
            setTelefono(getNewIncidenceOwnDriver().getTelefono());
        } catch (Exception e) {
            logger.error("Error al cargar los datos Vehiculo Tercero " + e);
        }
    }

    public void cargarVehiculoTercero() {
        logger.info("Cargando datos VehiculoTercero (Incidence Own Driver)");
        try {
            setNombrePropietario(getNewIncidenceThirdPartyVehicle().getNombrePropietario());
            setNombreConductor(getNewIncidenceThirdPartyVehicle().getNombreConductor());
            setDireccion1(getNewIncidenceThirdPartyVehicle().getDireccion1());
            setTelefono1(getNewIncidenceThirdPartyVehicle().getTelefono1());
            setDireccion2(getNewIncidenceThirdPartyVehicle().getDireccion2());
            setTelefono2(getNewIncidenceThirdPartyVehicle().getTelefono2());
            setNumeroLicenciaVehicle(getNewIncidenceThirdPartyVehicle().getNumeroLicencia());
            setVehiculoMarcaTipo(getNewIncidenceThirdPartyVehicle().getVehiculoMarcaTipo());
            setModelo(getNewIncidenceThirdPartyVehicle().getModelo());
            setPlacas(getNewIncidenceThirdPartyVehicle().getPlacas());
            setSerie(getNewIncidenceThirdPartyVehicle().getSerie());
            setCiaSeguros(getNewIncidenceThirdPartyVehicle().getCiaSeguros());
            setPoliza(getNewIncidenceThirdPartyVehicle().getPoliza());
            setCobertura(getNewIncidenceThirdPartyVehicle().getCobertura());
            setDeducible(getNewIncidenceThirdPartyVehicle().getDeducible());
            setVencimiento(getNewIncidenceThirdPartyVehicle().getVencimiento());
            setSiniestro(getNewIncidenceThirdPartyVehicle().getSiniestro());
            setAjustador(getNewIncidenceThirdPartyVehicle().getAjustador());
            setDatosVehiculoTercero(getNewIncidenceThirdPartyVehicle().getDatosVehiculoTercero());
            setRegistroIncidenceThirdPartyVehicleCompleto(true);
        } catch (Exception e) {
            logger.error("Error al cargar los datos Vehiculo Tercero " + e);
        }
    }

    public void guardarLesionesDaños() {
        logger.info("guardarLesionesDaños");
        try {
            if (getNewIncidence().getId() != null) {
                IncidenceDamage damage = new IncidenceDamage();
                damage.setIncidence(getNewIncidence());
                damage.setNombre(getNombre());
                damage.setEdad(getEdad());
                damage.setDireccion(getDireccion());
                damage.setTelefono(getTelefonoDamage());
                damage.setLesionesSufridad(getLesionesSufridad());
                damage.setCorreo(getCorreo());
                if (getAmbulancia()) {
                    damage.setAmbulancia(BasicType.ENEBLED);
                } else {
                    damage.setAmbulancia(BasicType.DISABLED);
                }
                if (getPaseMedico()) {
                    damage.setPaseMedico(BasicType.ENEBLED);
                } else {
                    damage.setPaseMedico(BasicType.DISABLED);
                }
                if (getIdHospital() != null && !getIdHospital().isEmpty()) {
                    damage.setHospital(new Hospitales(getIdHospital()));
                }
                switch (getRiesgo()) {
                    case "Conductor":
                        damage.setRiesgo(Riesgo.CONDUCTOR);
                        break;
                    case "RCV":
                        damage.setRiesgo(Riesgo.RCV);
                        break;
                    case "RCP":
                        damage.setRiesgo(Riesgo.RCP);
                        break;
                    default:
                        showMessage(FacesMessage.SEVERITY_WARN, "Advertencia", "No se seleccionó un riesgo existente");
                        logger.error("No se seleccionó un riesgo existente ");
                }
                getIncidenceController().addIncidenceDamage(damage, getLoggedUser(), true);
                setListIncidenceDamage(getIncidenceController().findAllIncidenceDamageByIncidence(getNewIncidence()));
                resetLesionesDanos();
                showMessage(FacesMessage.SEVERITY_INFO, "Guardado con éxito", "Lesiones y daños  guardado con éxito");
                logger.info("Lesiones y daños guardado con éxito");
            } else {
                showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de vincular el reporte principal");
                logger.error("Ocurrió un error al tratar de vincular el reporte principal");
            }
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar guardar las lesiones y daños");
            logger.error("guardarLesionesDaños() " + e);
        }
    }

    public void actualizarLesionesDaños() {
        logger.info("actualizarLesionesDaños");
        try {
            getNewIncidenceDamage().setNombre(getNombre());
            getNewIncidenceDamage().setEdad(getEdad());
            getNewIncidenceDamage().setDireccion(getDireccion());
            getNewIncidenceDamage().setTelefono(getTelefonoDamage());
            getNewIncidenceDamage().setLesionesSufridad(getLesionesSufridad());
            getNewIncidenceDamage().setCorreo(getCorreo());
            if (getAmbulancia()) {
                getNewIncidenceDamage().setAmbulancia(BasicType.ENEBLED);
            } else {
                getNewIncidenceDamage().setAmbulancia(BasicType.DISABLED);
            }
            if (getPaseMedico()) {
                getNewIncidenceDamage().setPaseMedico(BasicType.ENEBLED);
            } else {
                getNewIncidenceDamage().setPaseMedico(BasicType.DISABLED);
            }
            if (getIdHospital() != null && !getIdHospital().isEmpty()) {
                getNewIncidenceDamage().setHospital(new Hospitales(getIdHospital()));
            }
            switch (getRiesgo()) {
                case "Conductor":
                    getNewIncidenceDamage().setRiesgo(Riesgo.CONDUCTOR);
                    break;
                case "RCV":
                    getNewIncidenceDamage().setRiesgo(Riesgo.RCV);
                    break;
                case "RCP":
                    getNewIncidenceDamage().setRiesgo(Riesgo.RCP);
                    break;
                default:
                    showMessage(FacesMessage.SEVERITY_WARN, "Advertencia", "No se seleccionó un riesgo existente");
                    logger.error("No se seleccionó un riesgo existente ");
            }
            getIncidenceController().addIncidenceDamage(getNewIncidenceDamage(), getLoggedUser(), false);
            setListIncidenceDamage(getIncidenceController().findAllIncidenceDamageByIncidence(getNewIncidence()));
            resetLesionesDanos();
            showMessage(FacesMessage.SEVERITY_INFO, "Actualización realizada con éxito", "Lesiones y daños actualizado con éxito");
            logger.info("Lesiones y daños actualizado con éxito");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar actualizar las lesiones y daños");
            logger.error("actualizarLesionesDaños() " + e);
        }
    }

    public void resetLesionesDanos() {
        logger.info("resetLesionesDanos");
        setNewIncidenceDamage(null);
        setNombre("");
        setEdad("");
        setDireccion("");
        setTelefonoDamage("");
        setLesionesSufridad("");
        setAmbulancia(false);
        setPaseMedico(false);
        setIdHospital("");
        setRiesgo("");
        setCorreo("");
    }

    public void cargarLesionesDanos() {
        logger.info("Cargando datos Lesiones y daños");
        try {
            setNombre(getNewIncidenceDamage().getNombre());
            setEdad(getNewIncidenceDamage().getEdad());
            setDireccion(getNewIncidenceDamage().getDireccion());
            setTelefonoDamage(getNewIncidenceDamage().getTelefono());
            setLesionesSufridad(getNewIncidenceDamage().getLesionesSufridad());
            setAmbulancia(getNewIncidenceDamage().getAmbulancia().equals(BasicType.ENEBLED));
            setPaseMedico(getNewIncidenceDamage().getPaseMedico().equals(BasicType.ENEBLED));
            setIdHospital(getNewIncidenceDamage().getHospital() != null ? getNewIncidenceDamage().getHospital().getId() : "");
            setRiesgo(getNewIncidenceDamage().getRiesgo().getType());
            setCorreo(getNewIncidenceDamage().getCorreo());
        } catch (Exception e) {
            logger.error("Error al cargar los datos Lesiones y daños " + e);
        }
    }

    public void cargarDocumento(UploadedFile doc, String nombre, String identificadorPrincipal, String link) throws IOException {
        logger.info("handleFileUpload()");
        try {
            if (!doc.getFileName().isEmpty()) {
                try {
                    String nombreDocumentoNuevo = doc.getFileName();
                    String[] formato = nombreDocumentoNuevo.split("\\.", 2);
                    if (formato[1].equals("png") || formato[1].equals("jpeg") || formato[1].equals("jpg")) {
                        String extencion = nombreDocumentoNuevo;
                        String[] subString = extencion.split("\\.", 2);
                        String fileName = nombre + "." + subString[1];
                        InputStream inputStream = doc.getInputstream();
                        OutputStream outputStream = new FileOutputStream(fileName);
                        int bytesRead;
                        byte[] buffer = new byte[8192];
                        while ((bytesRead = inputStream.read(buffer, 0, 8192)) != -1) {
                            outputStream.write(buffer, 0, bytesRead);
                        }
                        outputStream.flush();
                        outputStream.close();
                        inputStream.close();
                        File xmlSubir = new File(fileName);

                        File nada = getControladorBucket().utilizarBucketId(getBundlePropertyFile().getString("aws.access.key"), getBundlePropertyFile().getString("aws.secret.access.key"), getBundlePropertyFile().getString("aws.region"), getBundlePropertyFile().getString("aws.bucket"), identificadorPrincipal, 0, xmlSubir, null);

                        if (xmlSubir.exists()) {
                            boolean eliminado = xmlSubir.delete();
                            if (eliminado) {
                                logger.info("Archivo eliminado correctamente");
                            } else {
                                logger.info("No se ha podido eliminar el archivo");
                            }
                        } else {
                            logger.info("El archivo no existe");
                        }
                        redireccionar(link);
                    } else {
                        logger.error("No ha seleccionado una imagen");
                        showMessage(FacesMessage.SEVERITY_ERROR, "Error", "No ha seleccionado un archivo");
                    }
                } catch (IOException e) {
                    logger.error("(1) handleFileUpload(): " + e);
                    showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de guardar el archivo");
                }
            } else {
                logger.error("Debe de seleccionar un archivo a subir");
                showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Debe de seleccionar un archivo a subir");
            }
        } catch (Exception e) {
            logger.error("(2) handleFileUpload(): " + e);
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de guardar el archivo");
            redireccionar(link);
        }
    }

    public void descargarDocumento(int tipo) throws IOException {
        String nombreDocumentoNuevo;
        String identificador;
        if (tipo == 1) {
            nombreDocumentoNuevo = getNewIncidence().getId() + "-" + getNewIncidence().getImgCredencial();
            identificador = getNewIncidence().getId();
        } else {
            nombreDocumentoNuevo = getNewIncidenceThirdPartyVehicle().getId() + "-" + getNewIncidenceThirdPartyVehicle().getImgCredencial();
            identificador = getNewIncidenceThirdPartyVehicle().getId();
        }
        File documento = getControladorBucket().utilizarBucketId(getBundlePropertyFile().getString("aws.access.key"), getBundlePropertyFile().getString("aws.secret.access.key"), getBundlePropertyFile().getString("aws.region"), getBundlePropertyFile().getString("aws.bucket"), identificador, 1, null, nombreDocumentoNuevo);
        String[] formato = nombreDocumentoNuevo.split("\\.", 2);
        // Válida el tipo de documento
        if (formato[1].equals("pdf")) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object response = context.getExternalContext().getResponse();

            if (response instanceof HttpServletResponse) {
                HttpServletResponse hrs = (HttpServletResponse) response;
                hrs.setContentType("application/pdf");
                hrs.addHeader("Content-Disposition", "attachment; filename=" + nombreDocumentoNuevo);

                try ( OutputStream outStream = hrs.getOutputStream();  FileInputStream fileInputStream = new FileInputStream(documento)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                        outStream.write(buffer, 0, bytesRead);
                    }
                    outStream.flush();
                    context.responseComplete();
                    if (documento.exists()) {
                        boolean eliminado = documento.delete();
                        if (eliminado) {
                            logger.info("Archivo eliminado correctamente");
                        } else {
                            logger.info("No se ha podido eliminar el archivo");
                        }
                    } else {
                        logger.info("El archivo no existe");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } else if (formato[1].equals("png") || formato[1].equals("jpeg") || formato[1].equals("jpg")) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object response = context.getExternalContext().getResponse();

            if (response instanceof HttpServletResponse) {
                HttpServletResponse hrs = (HttpServletResponse) response;
                hrs.setContentType("image/" + formato[1]);
                hrs.addHeader("Content-Disposition", "attachment; filename=" + nombreDocumentoNuevo);

                try ( OutputStream outStream = hrs.getOutputStream();  FileInputStream fileInputStream = new FileInputStream(documento)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                        outStream.write(buffer, 0, bytesRead);
                    }
                    outStream.flush();
                    context.responseComplete();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void redireccionar(String link) throws IOException {
        ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();
        String host = externalContext().getRequestServerName();
        if (host.equals("localhost")) {
            externalContext.redirect("/prase" + link);
        } else {
            externalContext.redirect(link);
        }
    }

    public void cargarDatosChofer() {
        logger.info("cargarDatosChofer()");
        try {

            Person driver = getNewIncidence().getDriver();
            setEdChPrimerNombre(driver.getFirstName());
            setEdChSegundoNombre(driver.getSecondName());
            setEdChPrimerApellido(driver.getLastName());
            setEdChSegundoApellido(driver.getMiddleName());
            setEdChLicencia(driver.getLicense());
            setEdChFechaNacimiento(driver.getBirthdate());
            setEdChCalle(driver.getDireccion());
            setEdChTelefono(driver.getTelefono());

        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Ocurrió un error al tratar descargar los datos del conductor");
            logger.error("cargarDatosChofer(): " + e);
        }
    }

    public void actualizarDatosChofer() {
        logger.info("actualizarDatosChofer()");
        try {

            if (getEdChPrimerNombre() != null || getEdChSegundoNombre() != null || getEdChPrimerApellido() != null || getEdChSegundoApellido() != null || getEdChLicencia() != null || getEdChFechaNacimiento() != null) {
                logger.info("Datos principales del conductor actualizados");

                getDriver().setFirstName(getEdChPrimerNombre());
                getDriver().setSecondName(getEdChSegundoNombre());
                getDriver().setLastName(getEdChPrimerApellido());
                getDriver().setMiddleName(getEdChSegundoApellido());
                getDriver().setLicense(getEdChLicencia());
                getDriver().setBirthdate(correcciónDeHr(getEdChFechaNacimiento(), 7));
                getDriver().setDireccion(getEdChCalle());
                getDriver().setTelefono(getEdChTelefono());
                getDriverController().updateDriver(getDriver(), getLoggedUser());
            }

            cargarDatosPoliza();
            cargarDatosDriver();
            resetformEditarChofer();

            showMessage(FacesMessage.SEVERITY_INFO, "Datos actualizados", "Los datos del conductor se actualizaron correctamente");
            logger.error("Los datos del conductor se actualizaron correctamente");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Ocurrió un error al tratar actualizar los datos del conductor");
            logger.error("actualizarDatosChofer(): " + e);
        }
    }

    public void resetformEditarChofer() {
        setEdChPrimerNombre(null);
        setEdChSegundoNombre(null);
        setEdChPrimerApellido(null);
        setEdChSegundoApellido(null);
        setEdChLicencia(null);
        setEdChCalle(null);
        setEdChLocalidad(null);
        setEdChRegion(null);
        setEdChFechaNacimiento(null);
        setEdChTelefono(null);
    }

    private Date correcciónDeHr(Date fecha, int horas) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(fecha);
        calendar.add(Calendar.HOUR_OF_DAY, horas);
        Date nuevaFecha = calendar.getTime();
        return nuevaFecha;
    }

    public String getIdIncidence() {
        return idIncidence;
    }

    public void setIdIncidence(String idIncidence) {
        this.idIncidence = idIncidence;
    }

    public IncidenceController getIncidenceController() {
        return incidenceController;
    }

    public void setIncidenceController(IncidenceController incidenceController) {
        this.incidenceController = incidenceController;
    }

    public CustomerController getCustomerController() {
        return customerController;
    }

    public void setCustomerController(CustomerController customerController) {
        this.customerController = customerController;
    }

    public AdminSalesController getAdminSalesController() {
        return adminSalesController;
    }

    public void setAdminSalesController(AdminSalesController adminSalesController) {
        this.adminSalesController = adminSalesController;
    }

    public PolizaController getPolizaController() {
        return polizaController;
    }

    public void setPolizaController(PolizaController polizaController) {
        this.polizaController = polizaController;
    }

    public HospitalesController getHospitalesController() {
        return hospitalesController;
    }

    public void setHospitalesController(HospitalesController hospitalesController) {
        this.hospitalesController = hospitalesController;
    }

    public GenericPersonController getGenericPersonController() {
        return genericPersonController;
    }

    public void setGenericPersonController(GenericPersonController genericPersonController) {
        this.genericPersonController = genericPersonController;
    }

    public int getTabActive() {
        return tabActive;
    }

    public void setTabActive(int tabActive) {
        this.tabActive = tabActive;
    }

    public List<Person> getListDrivers() {
        return listDrivers;
    }

    public void setListDrivers(List<Person> listDrivers) {
        this.listDrivers = listDrivers;
    }

    public String getSelectDriver() {
        return selectDriver;
    }

    public void setSelectDriver(String selectDriver) {
        this.selectDriver = selectDriver;
    }

    public List<Taxi> getListTaxis() {
        return listTaxis;
    }

    public void setListTaxis(List<Taxi> listTaxis) {
        this.listTaxis = listTaxis;
    }

    public String getSelectTaxi() {
        return selectTaxi;
    }

    public void setSelectTaxi(String selectTaxi) {
        this.selectTaxi = selectTaxi;
    }

    public List<Poliza> getListPoliza() {
        return listPoliza;
    }

    public void setListPoliza(List<Poliza> listPoliza) {
        this.listPoliza = listPoliza;
    }

    public String getSelectPoliza() {
        return selectPoliza;
    }

    public void setSelectPoliza(String selectPoliza) {
        this.selectPoliza = selectPoliza;
    }

    public List<Incidence> getListIncidence() {
        return listIncidence;
    }

    public void setListIncidence(List<Incidence> listIncidence) {
        this.listIncidence = listIncidence;
    }

    public Incidence getSelectIncidence() {
        return selectIncidence;
    }

    public void setSelectIncidence(Incidence selectIncidence) {
        this.selectIncidence = selectIncidence;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Boolean getRegistroInicialCompleto() {
        return registroInicialCompleto;
    }

    public void setRegistroInicialCompleto(Boolean registroInicialCompleto) {
        this.registroInicialCompleto = registroInicialCompleto;
    }

    public Incidence getNewIncidence() {
        return newIncidence;
    }

    public void setNewIncidence(Incidence newIncidence) {
        this.newIncidence = newIncidence;
    }

    public Boolean getPolizaSeleccinada() {
        return polizaSeleccinada;
    }

    public void setPolizaSeleccinada(Boolean polizaSeleccinada) {
        this.polizaSeleccinada = polizaSeleccinada;
    }

    public Date getFechaDeclaracion() {
        return fechaDeclaracion;
    }

    public void setFechaDeclaracion(Date fechaDeclaracion) {
        this.fechaDeclaracion = fechaDeclaracion;
    }

    public String getLugarDeclaracion() {
        return lugarDeclaracion;
    }

    public void setLugarDeclaracion(String lugarDeclaracion) {
        this.lugarDeclaracion = lugarDeclaracion;
    }

    public String getColoniaDeclaracion() {
        return coloniaDeclaracion;
    }

    public void setColoniaDeclaracion(String coloniaDeclaracion) {
        this.coloniaDeclaracion = coloniaDeclaracion;
    }

    public String getDelegacionDeclaracion() {
        return delegacionDeclaracion;
    }

    public void setDelegacionDeclaracion(String delegacionDeclaracion) {
        this.delegacionDeclaracion = delegacionDeclaracion;
    }

    public String getNarracionAsegurado() {
        return narracionAsegurado;
    }

    public void setNarracionAsegurado(String narracionAsegurado) {
        this.narracionAsegurado = narracionAsegurado;
    }

    public String getAfectacionesVehiculoSocio() {
        return afectacionesVehiculoSocio;
    }

    public void setAfectacionesVehiculoSocio(String afectacionesVehiculoSocio) {
        this.afectacionesVehiculoSocio = afectacionesVehiculoSocio;
    }

    public Boolean getRegistroDeclaracionCompleto() {
        return registroDeclaracionCompleto;
    }

    public void setRegistroDeclaracionCompleto(Boolean registroDeclaracionCompleto) {
        this.registroDeclaracionCompleto = registroDeclaracionCompleto;
    }

    public IncidenceStory getNewIncidenceStory() {
        return newIncidenceStory;
    }

    public void setNewIncidenceStory(IncidenceStory newIncidenceStory) {
        this.newIncidenceStory = newIncidenceStory;
    }

    public String getNombrePropietario() {
        return nombrePropietario;
    }

    public void setNombrePropietario(String nombrePropietario) {
        this.nombrePropietario = nombrePropietario;
    }

    public String getNombreConductor() {
        return nombreConductor;
    }

    public void setNombreConductor(String nombreConductor) {
        this.nombreConductor = nombreConductor;
    }

    public String getDireccion1() {
        return direccion1;
    }

    public void setDireccion1(String direccion1) {
        this.direccion1 = direccion1;
    }

    public String getTelefono1() {
        return telefono1;
    }

    public void setTelefono1(String telefono1) {
        this.telefono1 = telefono1;
    }

    public String getDireccion2() {
        return direccion2;
    }

    public void setDireccion2(String direccion2) {
        this.direccion2 = direccion2;
    }

    public String getTelefono2() {
        return telefono2;
    }

    public void setTelefono2(String telefono2) {
        this.telefono2 = telefono2;
    }

    public String getNumeroLicenciaVehicle() {
        return numeroLicenciaVehicle;
    }

    public void setNumeroLicenciaVehicle(String numeroLicenciaVehicle) {
        this.numeroLicenciaVehicle = numeroLicenciaVehicle;
    }

    public String getVehiculoMarcaTipo() {
        return vehiculoMarcaTipo;
    }

    public void setVehiculoMarcaTipo(String vehiculoMarcaTipo) {
        this.vehiculoMarcaTipo = vehiculoMarcaTipo;
    }

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getPlacas() {
        return placas;
    }

    public void setPlacas(String placas) {
        this.placas = placas;
    }

    public String getSerie() {
        return serie;
    }

    public void setSerie(String serie) {
        this.serie = serie;
    }

    public String getCiaSeguros() {
        return ciaSeguros;
    }

    public void setCiaSeguros(String ciaSeguros) {
        this.ciaSeguros = ciaSeguros;
    }

    public String getPoliza() {
        return poliza;
    }

    public void setPoliza(String poliza) {
        this.poliza = poliza;
    }

    public String getCobertura() {
        return cobertura;
    }

    public void setCobertura(String cobertura) {
        this.cobertura = cobertura;
    }

    public String getDeducible() {
        return deducible;
    }

    public void setDeducible(String deducible) {
        this.deducible = deducible;
    }

    public Date getVencimiento() {
        return vencimiento;
    }

    public void setVencimiento(Date vencimiento) {
        this.vencimiento = vencimiento;
    }

    public String getSiniestro() {
        return siniestro;
    }

    public void setSiniestro(String siniestro) {
        this.siniestro = siniestro;
    }

    public String getAjustador() {
        return ajustador;
    }

    public void setAjustador(String ajustador) {
        this.ajustador = ajustador;
    }

    public String getDatosVehiculoTercero() {
        return datosVehiculoTercero;
    }

    public void setDatosVehiculoTercero(String datosVehiculoTercero) {
        this.datosVehiculoTercero = datosVehiculoTercero;
    }

    public IncidenceThirdPartyVehicle getNewIncidenceThirdPartyVehicle() {
        return newIncidenceThirdPartyVehicle;
    }

    public void setNewIncidenceThirdPartyVehicle(IncidenceThirdPartyVehicle newIncidenceThirdPartyVehicle) {
        this.newIncidenceThirdPartyVehicle = newIncidenceThirdPartyVehicle;
    }

    public Boolean getRegistroIncidenceThirdPartyVehicleCompleto() {
        return registroIncidenceThirdPartyVehicleCompleto;
    }

    public void setRegistroIncidenceThirdPartyVehicleCompleto(Boolean registroIncidenceThirdPartyVehicleCompleto) {
        this.registroIncidenceThirdPartyVehicleCompleto = registroIncidenceThirdPartyVehicleCompleto;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getSecondName() {
        return secondName;
    }

    public void setSecondName(String secondName) {
        this.secondName = secondName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }

    public String getNumeroLicenciaDriver() {
        return numeroLicenciaDriver;
    }

    public void setNumeroLicenciaDriver(String numeroLicenciaDriver) {
        this.numeroLicenciaDriver = numeroLicenciaDriver;
    }

    public Date getFechaAltaLicencia() {
        return fechaAltaLicencia;
    }

    public void setFechaAltaLicencia(Date fechaAltaLicencia) {
        this.fechaAltaLicencia = fechaAltaLicencia;
    }

    public Date getFechaNacimiento() {
        return fechaNacimiento;
    }

    public void setFechaNacimiento(Date fechaNacimiento) {
        this.fechaNacimiento = fechaNacimiento;
    }

    public String getDomicilio() {
        return domicilio;
    }

    public void setDomicilio(String domicilio) {
        this.domicilio = domicilio;
    }

    public String getTelefono() {
        return telefono;
    }

    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }

    public IncidenceOwnDriver getNewIncidenceOwnDriver() {
        return newIncidenceOwnDriver;
    }

    public void setNewIncidenceOwnDriver(IncidenceOwnDriver newIncidenceOwnDriver) {
        this.newIncidenceOwnDriver = newIncidenceOwnDriver;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getEdad() {
        return edad;
    }

    public void setEdad(String edad) {
        this.edad = edad;
    }

    public String getDireccion() {
        return direccion;
    }

    public void setDireccion(String direccion) {
        this.direccion = direccion;
    }

    public String getTelefonoDamage() {
        return telefonoDamage;
    }

    public void setTelefonoDamage(String telefonoDamage) {
        this.telefonoDamage = telefonoDamage;
    }

    public String getLesionesSufridad() {
        return lesionesSufridad;
    }

    public void setLesionesSufridad(String lesionesSufridad) {
        this.lesionesSufridad = lesionesSufridad;
    }

    public Boolean getAmbulancia() {
        return ambulancia;
    }

    public void setAmbulancia(Boolean ambulancia) {
        this.ambulancia = ambulancia;
    }

    public Boolean getPaseMedico() {
        return paseMedico;
    }

    public void setPaseMedico(Boolean paseMedico) {
        this.paseMedico = paseMedico;
    }

    public List<Hospitales> getListHospitales() {
        return listHospitales;
    }

    public void setListHospitales(List<Hospitales> listHospitales) {
        this.listHospitales = listHospitales;
    }

    public String getIdHospital() {
        return idHospital;
    }

    public void setIdHospital(String idHospital) {
        this.idHospital = idHospital;
    }

    public String getRiesgo() {
        return riesgo;
    }

    public void setRiesgo(String riesgo) {
        this.riesgo = riesgo;
    }

    public IncidenceDamage getNewIncidenceDamage() {
        return newIncidenceDamage;
    }

    public void setNewIncidenceDamage(IncidenceDamage newIncidenceDamage) {
        this.newIncidenceDamage = newIncidenceDamage;
    }

    public String getMarcaP() {
        return marcaP;
    }

    public void setMarcaP(String marcaP) {
        this.marcaP = marcaP;
    }

    public String getTipoP() {
        return tipoP;
    }

    public void setTipoP(String tipoP) {
        this.tipoP = tipoP;
    }

    public String getModeloP() {
        return modeloP;
    }

    public void setModeloP(String modeloP) {
        this.modeloP = modeloP;
    }

    public String getColorP() {
        return colorP;
    }

    public void setColorP(String colorP) {
        this.colorP = colorP;
    }

    public String getRutaP() {
        return rutaP;
    }

    public void setRutaP(String rutaP) {
        this.rutaP = rutaP;
    }

    public String getPlacasP() {
        return placasP;
    }

    public void setPlacasP(String placasP) {
        this.placasP = placasP;
    }

    public String getNumeroSerie() {
        return numeroSerie;
    }

    public void setNumeroSerie(String numeroSerie) {
        this.numeroSerie = numeroSerie;
    }

    public String getNoMotor() {
        return noMotor;
    }

    public void setNoMotor(String noMotor) {
        this.noMotor = noMotor;
    }

    public String getNombreConductorP() {
        return nombreConductorP;
    }

    public void setNombreConductorP(String nombreConductorP) {
        this.nombreConductorP = nombreConductorP;
    }

    public String getNoTipoLicenciaP() {
        return noTipoLicenciaP;
    }

    public void setNoTipoLicenciaP(String noTipoLicenciaP) {
        this.noTipoLicenciaP = noTipoLicenciaP;
    }

    public String getLugarFechaAltaP() {
        return lugarFechaAltaP;
    }

    public void setLugarFechaAltaP(String lugarFechaAltaP) {
        this.lugarFechaAltaP = lugarFechaAltaP;
    }

    public String getDomicilioConductorP() {
        return domicilioConductorP;
    }

    public void setDomicilioConductorP(String domicilioConductorP) {
        this.domicilioConductorP = domicilioConductorP;
    }

    public String getFechaNacimientoConductorP() {
        return fechaNacimientoConductorP;
    }

    public void setFechaNacimientoConductorP(String fechaNacimientoConductorP) {
        this.fechaNacimientoConductorP = fechaNacimientoConductorP;
    }

    public String getTelefonoConductorP() {
        return telefonoConductorP;
    }

    public void setTelefonoConductorP(String telefonoConductorP) {
        this.telefonoConductorP = telefonoConductorP;
    }

    public String getNombreAsociadoP() {
        return nombreAsociadoP;
    }

    public void setNombreAsociadoP(String nombreAsociadoP) {
        this.nombreAsociadoP = nombreAsociadoP;
    }

    public String getEstatusPolizaP() {
        return estatusPolizaP;
    }

    public void setEstatusPolizaP(String estatusPolizaP) {
        this.estatusPolizaP = estatusPolizaP;
    }

    public String getDireccionP() {
        return direccionP;
    }

    public void setDireccionP(String direccionP) {
        this.direccionP = direccionP;
    }

    public List<IncidenceOwnDriver> getListIncidenceOwnDriver() {
        return listIncidenceOwnDriver;
    }

    public void setListIncidenceOwnDriver(List<IncidenceOwnDriver> listIncidenceOwnDriver) {
        this.listIncidenceOwnDriver = listIncidenceOwnDriver;
    }

    public List<IncidenceDamage> getListIncidenceDamage() {
        return listIncidenceDamage;
    }

    public void setListIncidenceDamage(List<IncidenceDamage> listIncidenceDamage) {
        this.listIncidenceDamage = listIncidenceDamage;
    }

    public BucketController getControladorBucket() {
        return controladorBucket;
    }

    public void setControladorBucket(BucketController controladorBucket) {
        this.controladorBucket = controladorBucket;
    }

    public UploadedFile getFileCredencialConductor() {
        return fileCredencialConductor;
    }

    public void setFileCredencialConductor(UploadedFile fileCredencialConductor) {
        this.fileCredencialConductor = fileCredencialConductor;
    }

    public UploadedFile getFileCredencialConductorTercero() {
        return fileCredencialConductorTercero;
    }

    public void setFileCredencialConductorTercero(UploadedFile fileCredencialConductorTercero) {
        this.fileCredencialConductorTercero = fileCredencialConductorTercero;
    }

    public String getLinkLocal() {
        return linkLocal;
    }

    public void setLinkLocal(String linkLocal) {
        this.linkLocal = linkLocal;
    }

    public String getLinkImg() {
        return linkImg;
    }

    public void setLinkImg(String linkImg) {
        this.linkImg = linkImg;
    }

    public String getEdChPrimerNombre() {
        return edChPrimerNombre;
    }

    public void setEdChPrimerNombre(String edChPrimerNombre) {
        this.edChPrimerNombre = edChPrimerNombre;
    }

    public String getEdChSegundoNombre() {
        return edChSegundoNombre;
    }

    public void setEdChSegundoNombre(String edChSegundoNombre) {
        this.edChSegundoNombre = edChSegundoNombre;
    }

    public String getEdChPrimerApellido() {
        return edChPrimerApellido;
    }

    public void setEdChPrimerApellido(String edChPrimerApellido) {
        this.edChPrimerApellido = edChPrimerApellido;
    }

    public String getEdChSegundoApellido() {
        return edChSegundoApellido;
    }

    public void setEdChSegundoApellido(String edChSegundoApellido) {
        this.edChSegundoApellido = edChSegundoApellido;
    }

    public String getEdChLicencia() {
        return edChLicencia;
    }

    public void setEdChLicencia(String edChLicencia) {
        this.edChLicencia = edChLicencia;
    }

    public String getEdChCalle() {
        return edChCalle;
    }

    public void setEdChCalle(String edChCalle) {
        this.edChCalle = edChCalle;
    }

    public String getEdChLocalidad() {
        return edChLocalidad;
    }

    public void setEdChLocalidad(String edChLocalidad) {
        this.edChLocalidad = edChLocalidad;
    }

    public String getEdChRegion() {
        return edChRegion;
    }

    public void setEdChRegion(String edChRegion) {
        this.edChRegion = edChRegion;
    }

    public Date getEdChFechaNacimiento() {
        return edChFechaNacimiento;
    }

    public void setEdChFechaNacimiento(Date edChFechaNacimiento) {
        this.edChFechaNacimiento = edChFechaNacimiento;
    }

    public String getEdChTelefono() {
        return edChTelefono;
    }

    public void setEdChTelefono(String edChTelefono) {
        this.edChTelefono = edChTelefono;
    }

    public DriverController getDriverController() {
        return driverController;
    }

    public void setDriverController(DriverController driverController) {
        this.driverController = driverController;
    }

    public List<User> getListUsuarios() {
        return listUsuarios;
    }

    public void setListUsuarios(List<User> listUsuarios) {
        this.listUsuarios = listUsuarios;
    }

    public UserController getUserController() {
        return UserController;
    }

    public void setUserController(UserController UserController) {
        this.UserController = UserController;
    }

    public String getSelectUsuario() {
        return selectUsuario;
    }

    public void setSelectUsuario(String selectUsuario) {
        this.selectUsuario = selectUsuario;
    }

    public List<Person> getDrivers() {
        return drivers;
    }

    public void setDrivers(List<Person> drivers) {
        this.drivers = drivers;
    }

    public List<TipoSiniestro> getTipoSiniestro() {
        return tipoSiniestro;
    }

    public void setTipoSiniestro(List<TipoSiniestro> tipoSiniestro) {
        this.tipoSiniestro = tipoSiniestro;
    }

    public String getSelectedDriver() {
        return selectedDriver;
    }

    public void setSelectedDriver(String selectedDriver) {
        this.selectedDriver = selectedDriver;
    }

    public String getSelectedTipoSiniestro() {
        return selectedTipoSiniestro;
    }

    public void setSelectedTipoSiniestro(String selectedTipoSiniestro) {
        this.selectedTipoSiniestro = selectedTipoSiniestro;
    }

    public TipoSiniestroController getTipoSiniestroController() {
        return tipoSiniestroController;
    }

    public void setTipoSiniestroController(TipoSiniestroController tipoSiniestroController) {
        this.tipoSiniestroController = tipoSiniestroController;
    }

    public Person getDriver() {
        return driver;
    }

    public void setDriver(Person driver) {
        this.driver = driver;
    }

    public String getCorreo() {
        return correo;
    }

    public void setCorreo(String correo) {
        this.correo = correo;
    }

    public List<IncidenceThirdPartyVehicle> getIncidenceThirdPartyVehicle() {
        return incidenceThirdPartyVehicle;
    }

    public void setIncidenceThirdPartyVehicle(List<IncidenceThirdPartyVehicle> incidenceThirdPartyVehicle) {
        this.incidenceThirdPartyVehicle = incidenceThirdPartyVehicle;
    }

    public Date getFechaActual() {
        return fechaActual;
    }

    public void setFechaActual(Date fechaActual) {
        this.fechaActual = fechaActual;
    }

}
