package com.fp.frontend.controller.armas.parametros;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;

import org.primefaces.context.RequestContext;

import com.fp.dto.Request;
import com.fp.dto.Response;
import com.fp.dto.query.DtoQuery;
import com.fp.dto.query.Filter;
import com.fp.dto.save.DtoSave;
import com.fp.frontend.controller.AbstractController;
import com.fp.frontend.controller.pgeneral.gene.CatalogDetailController;
import com.fp.frontend.enums.EnumLovOption;
import com.fp.frontend.helper.CallerHelper;
import com.fp.frontend.helper.MessageHelper;
import com.fp.persistence.parmas.eval.TarmPreguntas;
import com.fp.persistence.parmas.eval.TarmRespuestas;

/**
 * Clase controller de respuestas para preguntas
 *
 * @author Christian Pazmino
 * @version 2.1
 */
@ManagedBean
@ViewScoped
public class RespuestasLovController extends AbstractController<TarmRespuestas> {

    private static final long serialVersionUID = 1L;
    /**
     * Variable que contiene la pregunta a las que corresponden las respuestas
     * presentadas
     */
    private TarmPreguntas pregunta;
    /**
     * Variable de tipo boleano que indica si una respuesta es o no correcta
     */
    private Boolean isCorrecta;
    /**
     * Estado de la respuesta
     */
    private String estado;
    /**
     * Constante usada para referirse al estado activo de una respuesta
     */
    private final String ESTADOACTIVO = "ACT";
    /**
     * Constante usada para referirse al estado inactivo de una respuesta
     */
    private final String ESTADOINACTIVO = "INA";

    /**
     * Referencia al controlador de la clase pregunta
     */
    @ManagedProperty(value = "#{preguntasParaEvaluacionesController}")
    private PreguntasParaEvaluacionesController preguntasController;

    public RespuestasLovController() throws Exception {
        super(TarmRespuestas.class);
    }

    @PostConstruct
    private void postconstruct() {
        this.init();
        try {
            String preguntaPK = CallerHelper.getLovParameter("preguntaPK");
            pregunta = PreguntasParaEvaluacionesController.find(preguntaPK).get(0);
            if (pregunta.getEstadopregunta().equalsIgnoreCase(ESTADOACTIVO)) {
                estado = CatalogDetailController.findxCodigoCodcatalogo(ESTADOACTIVO, "ESTADOPRUEBAS").getDescription();
            } else if (pregunta.getEstadopregunta().equalsIgnoreCase(ESTADOINACTIVO)) {
                estado = CatalogDetailController.findxCodigoCodcatalogo(ESTADOINACTIVO, "ESTADOPRUEBAS").getDescription();
            }
            this.addFilter("cpregunta", pregunta.getPk().toString());
            this.querydatabase();
            //super.startQuery();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * Incializa el controlador, cuando se esta utilizando una pagina que utliza
     * el controlador.
     */
    private void init() {
        try {
            this.recperpage = 15; // Cambiar al # reg a mirar.
            this.lrecord = new ArrayList<>();
            this.beanalias = "RESPUESTASLOV";
        } catch (Exception e) {
            MessageHelper.setMessageError(e);
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    protected void querydatabase() {
        try {

            Request request = this.callerhelper.getRequest();
            DtoQuery dto = super.getDtoQuery(true);
            dto.setOrderby("t.descripcion");

            Filter f = new Filter();
            f.setSql("t.isactive = 'Y'");
            dto.addFiltro(f);

            HashMap<String, DtoQuery> mtables = new HashMap<String, DtoQuery>();
            mtables.put(this.beanalias, dto); // permite adicionar mas de una tabla.

            request.setQueryTables(mtables);

            Response resp = this.callerhelper.executeQuery(request);

            if (resp.getResponseCode().compareTo(Response.RESPONSE_OK) != 0) {
                this.lrecord = new ArrayList<TarmRespuestas>();
                MessageHelper.setMessageError(resp);
            } else {
                this.lrecord = (List<TarmRespuestas>) resp.get(this.beanalias);
                super.postQuery(this.lrecord);
            }

        } catch (Throwable e) {
            MessageHelper.setMessageError(e);
        }
    }

    /**
     * Abre el dialogo de crear/editar respuestas desde la pantalla de
     * respuestas
     */
    public static void openLov(Map<String, List<String>> params) {
        Map<String, Object> options = new HashMap<String, Object>();
        options.put(EnumLovOption.MODAL.getLabel(), true);
        options.put(EnumLovOption.HEIGHT.getLabel(), 450);
        options.put(EnumLovOption.WIDTH.getLabel(), 700);
        options.put(EnumLovOption.RESIZABLE.getLabel(), false);

        RequestContext.getCurrentInstance().openDialog("/pages/armas/lov/respuestasLov.xhtml", options, params);
    }

    /**
     * Crea una instancia y marca el registro como nuevo.
     *
     * @throws Exception
     */
    @Override
    public void create() throws Exception {
        super.create();
        isCorrecta = false;
        record.setCpregunta(pregunta.getPk());
        record.setIsactive("Y");
    }

    /**
     * Actualiza la lista de registros a grabar
     *
     * @throws Exception
     */
    public void update() throws Exception {
        if (record.getEscorrecta() == null) {
            record.setEscorrecta("N");
        }
        super.update();
    }

    public void eliminarLogico() throws Exception {
        record.setIsactive("N");
        super.update();
        this.lrecord.remove(record);

    }

    @Override
    public void save() {
        try {
            if (lrecord.size() >= 2) {
                int numRespuestasCorrectas = 0;
                for (TarmRespuestas respuesta : lrecord) {
                    if (respuesta.getEscorrecta().equals("Y")) {
                        numRespuestasCorrectas++;
                    }
                    if (numRespuestasCorrectas > 1) {
                        break;
                    }
                }
                if (numRespuestasCorrectas == 1) {
                    DtoSave dtosave = super.getDtoSave();
                    dtosave.setReturnpk(true); // Para que el core devuelva el pk de los
                    // registros nuevos.
                    HashMap<String, DtoSave> msave = new HashMap<String, DtoSave>();

                    Request request = callerhelper.getRequest();
                    msave.put(beanalias, dtosave); // adicionar metadata de
                    // mantenimiento para cada tabla.

                    request.setSaveTables(msave);
                    Response resp = callerhelper.executeSave(request);
                    if (resp.getResponseCode().compareTo(Response.RESPONSE_OK) == 0) {
                        this.postCommit(resp);
                        MessageHelper.setMessageInfo(resp);
                    } else {
                        MessageHelper.setMessageError(resp);
                    }
                    // Cambiar el estado de la pregunta
                    if (pregunta.getEstadopregunta().equalsIgnoreCase(ESTADOINACTIVO)) {
                        pregunta.isnew = false;
                        pregunta.setEstadopregunta(ESTADOACTIVO);
                        preguntasController.update(pregunta);
                        preguntasController.save();
                    }

                    RequestContext.getCurrentInstance().closeDialog(pregunta);
                } else if (numRespuestasCorrectas > 1) {
                    MessageHelper.setMessageError("LA PREGUNTA PUEDE TENER MARCADA SOLO UNA RESPUESTA CORRECTA");
                } else if (numRespuestasCorrectas == 0) {
                    MessageHelper.setMessageError("LA PREGUNTA DEBE TENER MARCADA UNA RESPUESTA CORRECTA");
                }
            } else {
                MessageHelper.setMessageError("DEBEN HABER AL MENOS DOS RESPUESTAS");
            }
        } catch (Throwable e) {
            MessageHelper.setMessageError(e);
        }
    }

    public TarmPreguntas getPregunta() {
        return pregunta;
    }

    public void setPregunta(TarmPreguntas pregunta) {
        this.pregunta = pregunta;
    }

    public Boolean getIsCorrecta() {
        return isCorrecta;
    }

    public void setIsCorrecta(Boolean isCorrecta) {
        this.isCorrecta = isCorrecta;
    }

    /**
     * Metodo para manejar el evento change en el CheckBox "respuesta correcta"
     * y convertir valor TRUE en "Y" y FALSE en "N"
     */
    public void onChangeEsCorrecta() {
        if (isCorrecta) {
            record.setEscorrecta("Y");
        } else {
            record.setEscorrecta("N");
        }
    }

    public String getEstado() {
        return estado;
    }

    public void setEstado(String estado) {
        this.estado = estado;
    }

    public PreguntasParaEvaluacionesController getPreguntasController() {
        return preguntasController;
    }

    public void setPreguntasController(
            PreguntasParaEvaluacionesController preguntasController) {
        this.preguntasController = preguntasController;
    }

}
