
package de.ivu.elect.business.personenpruefung.boundary.dubletten;

import static java.util.Objects.nonNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.lang3.tuple.Pair;

import de.ivu.elect.business.person.entity.PersonenVerknuepfungPK;
import de.ivu.elect.business.person.entity.Personendaten;
import de.ivu.elect.business.person.entity.VerknuepfungsGrundlage;
import de.ivu.elect.business.person.entity.VerknuepfungsStatus;

public class DublettenPersonendatenPair<P extends Personendaten> extends Pair<P, P> {

  private static final long serialVersionUID = 1L;

  private final PersonenVerknuepfungPK personenVerknuepfungPk;

  private final VerknuepfungsGrundlage verknuepfungsGrundlage;

  private final VerknuepfungsStatus verknuepfungsStatus;

  private final P left;

  private final P right;

  public DublettenPersonendatenPair(PersonenVerknuepfungPK personenVerknuepfungPk, VerknuepfungsGrundlage verknuepfungsGrundlage, VerknuepfungsStatus verknuepfungsStatus, P one, P another) {
    super();

    this.personenVerknuepfungPk = personenVerknuepfungPk;

    this.verknuepfungsGrundlage = verknuepfungsGrundlage;
    this.verknuepfungsStatus = verknuepfungsStatus;

    List<P> leftRight = computeLeftRightSorted(one, another);

    this.left = leftRight.get(0);
    this.right = leftRight.get(1);
  }

  public PersonenVerknuepfungPK getPersonenVerknuepfungPk() {
    return personenVerknuepfungPk;
  }

  public VerknuepfungsGrundlage getVerknuepfungsGrundlage() {
    return verknuepfungsGrundlage;
  }

  public VerknuepfungsStatus getVerknuepfungsStatus() {
    return verknuepfungsStatus;
  }

  public boolean hasLeft() {
    return nonNull(getLeft());
  }

  @Override
  public P getLeft() {
    return left;
  }

  public boolean hasRight() {
    return nonNull(getRight());
  }

  @Override
  public P getRight() {
    return right;
  }

  @Override
  public P setValue(P value) {
    throw new UnsupportedOperationException();
  }

  public List<P> toList() {
    return Arrays.asList(getLeft(), getRight());
  }

  private List<P> computeLeftRightSorted(P one, P another) {
    List<P> result = new ArrayList<>();
    result.add(one);
    result.add(another);

    result.sort((a, b) -> {
      if (a != null) {
        if (b != null) {
          return a.getPk().compareTo(b.getPk());
        }

        return -1;
      }

      if (b != null) {
        return 1;
      }

      return 0;
    });

    return result;
  }
}
