
package de.ivu.elect.presentation.ergebnis;

import java.util.List;

import javax.annotation.PostConstruct;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;

import de.ivu.elect.business.ergebnis.boundary.ErgebnisExtendedDAO;
import de.ivu.elect.business.ergebnis.entity.Ergebnis;
import de.ivu.elect.business.ergebnis.entity.Ergebnisart;
import de.ivu.elect.business.security.UseCasePermission;
import de.ivu.elect.business.sitzberechnung.control.SitzberechnungsalgorithmusFinder;
import de.ivu.elect.business.sitzberechnung.entity.SitzberechnungsalgorithmusKonfiguration;
import de.ivu.elect.business.wahl.boundary.WahlNichtAusgewaehltException;
import de.ivu.elect.business.wahl.boundary.WahldurchfuehrungSessionSelect;
import de.ivu.elect.jee.faces.PreConditionCheck;
import de.ivu.elect.jee.presentation.dynamicform.AdvancedDynaFormModel;
import de.ivu.elect.jee.presentation.dynamicform.FormBuilder;
import de.ivu.elect.jee.presentation.redirect.Redirect;
import de.ivu.elect.jee.presentation.view.AbstractView;
import de.ivu.elect.presentation.View;
import de.ivu.elect.presentation.ergebnis.form.ErgebnisBerechnenKonflikteAutomatischLoesenProperty;
import de.ivu.elect.presentation.ergebnis.form.ErgebnisBerechnenKonflikteUebernehmenProperty;
import de.ivu.elect.presentation.hilfe.KeineOnlineHilfe;
import de.ivu.elect.presentation.hilfe.OnlineHilfeId;

@OnlineHilfeId(KeineOnlineHilfe.KEINE_ONLINE_HILFE)
@RequestScoped
@Named(ErgebnisBerechnenView.COMPONENT_NAME)
@View(viewId = ErgebnisBerechnenView.VIEW_ID, useCase = UseCasePermission.ERGEBNIS_BERECHNUNG_AUSLOESEN)
public class ErgebnisBerechnenView extends AbstractView {

  public static final String VIEW_ID = "/ergebnis/ergebnis-berechnen.xhtml";

  public static final String COMPONENT_NAME = "ergebnisBerechnenView";

  private static final long serialVersionUID = 1L;

  @Inject
  private transient WahldurchfuehrungSessionSelect wahldurchfuehrungSessionSelect;

  @Inject
  private transient SitzberechnungsalgorithmusFinder sitzberechnungsalgorithmusFinder;

  @Inject
  private transient ErgebnisExtendedDAO ergebnisExtendedDAO;

  private SitzberechnungsalgorithmusKonfiguration sitzberechnungsalgorithmusKonfiguration;

  private ErgebnisBerechnenKonflikteUebernehmenProperty ergebnisBerechnenKonflikteUebernehmenProperty;

  private ErgebnisBerechnenKonflikteAutomatischLoesenProperty ergebnisBerechnenKonflikteAutomatischLoesenProperty;

  private Ergebnis ergebnis;

  private transient AdvancedDynaFormModel model;

  private List<Ergebnis> ergebnisseZurWahl;

  @PreConditionCheck
  public String checkCondition() {
    if (isWahlSelected()) {
      return null;
    }

    throw new WahlNichtAusgewaehltException();
  }

  public AdvancedDynaFormModel getModel() {
    if (model == null) {
      FormBuilder formBuilder = new FormBuilder();
      ergebnisBerechnenKonflikteAutomatischLoesenProperty = new ErgebnisBerechnenKonflikteAutomatischLoesenProperty(sitzberechnungsalgorithmusKonfiguration);
      formBuilder.addProperty(ergebnisBerechnenKonflikteAutomatischLoesenProperty);
      formBuilder.addProperty(ergebnis.getProperties().getNameProperty());
      formBuilder.addProperty(ergebnis.getProperties().getErgebnisartProperty()).readonly(); // TODO festlegen, erstmal nur endgültige berechnen
      ergebnisBerechnenKonflikteUebernehmenProperty = new ErgebnisBerechnenKonflikteUebernehmenProperty(getErgebnisseZurWahl());
      formBuilder.addProperty(ergebnisBerechnenKonflikteUebernehmenProperty);
      model = formBuilder.createModel();
    }
    return model;
  }

  private boolean isWahlSelected() {
    return wahldurchfuehrungSessionSelect.isSelected();
  }

  @PostConstruct
  public void init() {
    ergebnis = new Ergebnis();
    ergebnis.setErgebnisart(Ergebnisart.ENDGUELTIG); // TODO überdenken
    sitzberechnungsalgorithmusKonfiguration = sitzberechnungsalgorithmusFinder.getSitzberechnungsalgorithmus(wahldurchfuehrungSessionSelect.getEntity()).getDefaultKonfiguration();
    ergebnisseZurWahl = ergebnisExtendedDAO.findByWahlOrderByName(wahldurchfuehrungSessionSelect.getEntity());
  }

  @Redirect
  public String ergebnisBerechnen() {
    throw new UnsupportedOperationException("IMPLEMENT ME!");
    /*
     * // erstmal nur Endgültiges Ergebnis berechnen ErgebnisberechnungsErgebnis berechnungsergebnis =
     * ergebnisberechnung.uebernehmeStimmeneingabenUndBerechneNeuesErgebnis(wahldurchfuehrungSessionSelect.getEntity(), ergebnis.getErgebnisart(), ergebnis.getName(), principal.getName(),
     * sitzberechnungsalgorithmusKonfiguration, ergebnisBerechnenKonflikteUebernehmenProperty.getValue()); Ergebnis neuesErgegbnis = berechnungsergebnis.getErgebnis();
     *
     * if (ergebnisZurBearbeitungAuswaehlenAction.isActionPossible(neuesErgegbnis)) { ergebnisZurBearbeitungAuswaehlenAction.action(neuesErgegbnis); }
     *
     * if (berechnungsergebnis.isUngeloesteKonflikteVorhanden()) { messages.addWarnMessage("ergebnis.berechnet.success.message.ungeloeste.konflikte.vorhanden", neuesErgegbnis.getName()); return
     * ErgebnisKonfliktSearchView.VIEW_ID; }
     *
     * messages.addInfoMessage("ergebnis.berechnet.success.message", neuesErgegbnis.getName());
     *
     * return KandidaturGewaehltSearchView.VIEW_ID;
     */
  }

  @Redirect
  public String cancel() {
    return ErgebnisSearchView.VIEW_ID;
  }

  protected List<Ergebnis> getErgebnisseZurWahl() {
    return ergebnisseZurWahl;
  }
}
