
package de.ivu.elect.presentation.personenpruefung.form;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.application.FacesMessage.Severity;
import javax.inject.Inject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import de.ivu.elect.business.anschrift.entity.Anschrift;
import de.ivu.elect.business.anschrift.entity.AnschriftArt;
import de.ivu.elect.business.anschrift.entity.AnschriftProperties;
import de.ivu.elect.business.person.control.GeschlechtFilter;
import de.ivu.elect.business.person.entity.Personendaten;
import de.ivu.elect.business.person.entity.PersonendatenProperties;
import de.ivu.elect.business.person.entity.PersonendatenProperties.GeschlechtProperty;
import de.ivu.elect.business.personenregister.boundary.PersonendatenPersonenregisterPersonendatenMatcherResolver;
import de.ivu.elect.business.personenregister.boundary.PersonenregisterByOrdnungsmerkmalSearchParameters;
import de.ivu.elect.business.personenregister.boundary.PersonenregisterByPersonendatenSearchParameters;
import de.ivu.elect.business.personenregister.control.PersonenregisterPersonendatenMatcher;
import de.ivu.elect.business.personenregister.control.PersonenregisterPersonendatenMatcherResult;
import de.ivu.elect.business.personenregister.entity.PersonenregisterAnschrift;
import de.ivu.elect.business.personenregister.entity.PersonenregisterAnschriftProperties;
import de.ivu.elect.business.personenregister.entity.PersonenregisterMeta;
import de.ivu.elect.business.personenregister.entity.PersonenregisterPersonendaten;
import de.ivu.elect.business.personenregister.entity.PersonenregisterPersonendatenProperties;
import de.ivu.elect.business.staat.entity.Staat;
import de.ivu.elect.jee.presentation.dynamicform.AbstractDateProperty;
import de.ivu.elect.jee.presentation.dynamicform.AbstractStringProperty;
import de.ivu.elect.jee.presentation.dynamicform.FormBuilder;
import de.ivu.elect.jee.presentation.dynamicform.Property;
import de.ivu.elect.presentation.anschrift.form.AnschriftViewFormBuilder;
import de.ivu.elect.presentation.person.form.PersonendatenSearchFormBuilder;
import de.ivu.elect.presentation.person.form.PersonendatenViewFormBuilder;
import de.ivu.elect.presentation.person.form.StaatsangehoerigkeitProperty;
import de.ivu.elect.presentation.personenregister.form.AbstractPersonenregisterPropertiesViewFormBuilder;


import static org.apache.commons.lang3.StringUtils.isBlank;
import static org.apache.commons.lang3.StringUtils.isNotBlank;

public class PersonenKonfliktPersonenregisterAbgleichAufloesenViewFormBuilder extends AbstractPersonenregisterPropertiesViewFormBuilder {

  private static final Logger LOG = LoggerFactory.getLogger(PersonenKonfliktPersonenregisterAbgleichAufloesenViewFormBuilder.class);

  private static final long serialVersionUID = 1L;

  @Inject
  private transient PersonenregisterMeta personenregisterMeta;

  @Inject
  private transient PersonendatenViewFormBuilder personendatenViewFormBuilder;

  @Inject
  private transient AnschriftViewFormBuilder anschriftViewFormBuilder;

  @Inject
  private transient GeschlechtFilter geschlechtFilter;

  @Inject
  private transient PersonendatenPersonenregisterPersonendatenMatcherResolver personendatenPersonenregisterPersonendatenMatcherResolver;

  @Inject
  private transient PersonendatenSearchFormBuilder entityMitPersonendatenSearchFormBuilder;

  private String verificationMessageAttributeToMatchAutomatischUebernehmbar;

  private String verificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar;

  private String verificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar;

  private String verificationMessageValueAehnlich;

  public PersonenKonfliktPersonenregisterAbgleichAufloesenViewFormBuilder() {
    super();
  }

  private boolean isPropertiesGlobalReadonlySupported() {
    return isPropertiesGlobalReadonly() && !isPersonenregisterAbgleichUeberschreibbar();
  }

  protected boolean isPropertiesGlobalReadonly() {
    return false;
  }

  protected PersonenregisterPersonendatenMatcher getMatcher(Personendaten personendaten) {
    return personendatenPersonenregisterPersonendatenMatcherResolver.getMatcher(personendaten);
  }

  public void addProperties(FormBuilder formBuilder, PersonenregisterByPersonendatenSearchParameters searchParameters) {
    entityMitPersonendatenSearchFormBuilder.addPersonendatenProperties(formBuilder, searchParameters);
  }

  public void addProperties(FormBuilder formBuilder, PersonenregisterByOrdnungsmerkmalSearchParameters searchParameters) {
    formBuilder.addProperty(searchParameters.getOrdnungsmerkmalProperty());
  }

  public void addVerifiedProperties(FormBuilder formBuilder, Personendaten personendaten, PersonenregisterPersonendaten personenregisterPersonendaten) {
    PersonenregisterPersonendatenMatcher matcher = getMatcher(personendaten);
    boolean matcherEnabled = personenregisterPersonendaten != null;

    Anschrift anschrift = personendaten.getAnschrift();
    PersonenregisterAnschrift personenregisterAnschrift = fixNullToEmptyPersonenregisterAnschrift(personenregisterPersonendaten);

    addVerifiedPersonendatenProperties(formBuilder, matcher, matcherEnabled, personendaten, personenregisterPersonendaten);
    setVerifiedPersonendatenPropertiesRequired(formBuilder, personendaten);
    setVerifiedPersonendatenPropertiesOptionalIfUndefined(formBuilder, personendaten);

    addVerifiedAnschriftProperties(formBuilder, matcher, matcherEnabled, personendaten, anschrift, personenregisterAnschrift);
    setVerifiedAnschriftPropertiesRequired(formBuilder, personendaten, anschrift);
    setVerifiedAnschriftPropertiesOptionalIfUndefined(formBuilder, personendaten, anschrift);

    if (isPropertiesGlobalReadonlySupported()) {
      formBuilder.globalReadonly();
    }
  }

  protected void addVerifiedPersonendatenProperties(FormBuilder formBuilder, PersonenregisterPersonendatenMatcher matcher, boolean matcherEnabled, Personendaten personendaten,
      PersonenregisterPersonendaten personenregisterPersonendaten) {
    PersonendatenProperties personendatenProperties = personendaten.getProperties();

    formBuilder.addProperty(personendatenProperties.getExternesOrdnungsmerkmalProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchOrdnungsmerkmal(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getAnredeProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchAnrede(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getTitelProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchTitel(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getFamiliennameBestandteilProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchFamiliennameBestandteil(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getFamiliennameProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchFamilienname(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getRufnameProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchVorname(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getVornamenProperty());

    GeschlechtProperty geschlechtProperty = personendatenProperties.getGeschlechtProperty();
    geschlechtProperty.setValueFilter(geschlechtFilter);

    formBuilder.addProperty(geschlechtProperty);
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchGeschlecht(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getGeburtsdatumProperty());
    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchGeburtsdatum(personendaten, personenregisterPersonendaten));
    }

    List<StaatsangehoerigkeitProperty> staatsangehoerigkeitProperties = getStaatsangehoerigkeitPropertiesOrDefault(personendaten, personenregisterPersonendaten);

    for (StaatsangehoerigkeitProperty property : staatsangehoerigkeitProperties) {
      formBuilder.addProperty(property);

      if (staatsangehoerigkeitProperties.indexOf(property) == 0 && matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchStaatsangehoerigkeiten(personendaten, personenregisterPersonendaten));
      }
    }

    formBuilder.addProperty(personendatenProperties.getWahlrechtsausschlussProperty());

    if (matcherEnabled) {
      tryAddVerificationMessage(formBuilder, matcher.matchWahlrechtsausschluss(personendaten, personenregisterPersonendaten));
    }

    formBuilder.addProperty(personendatenProperties.getPersonStatusProperty()).readonly();

    setVerifiedPersonendatenPropertiesRequired(formBuilder, personendaten);
  }

  protected void setVerifiedPersonendatenPropertiesRequired(FormBuilder formBuilder, Personendaten personendaten) {
    personendatenViewFormBuilder.setBasicPersonendatenPropertiesRequired(formBuilder, personendaten);
  }

  // ELECT-8262
  private void setVerifiedPersonendatenPropertiesOptionalIfUndefined(FormBuilder formBuilder, Personendaten personendaten) {
    PersonendatenProperties personendatenProperties = personendaten.getProperties();

    // Mangels aktueller Funktion, über alle Properties iterieren zu können, also alle bekannten Properties einzeln...
    AbstractStringProperty familiennameProperty = personendatenProperties.getFamiliennameProperty();
    if (formBuilder.containsProperty(familiennameProperty)) {
      formBuilder.selectProperty(familiennameProperty).withRequired(familiennameProperty.isRequired() && familiennameProperty.hasValue());
    }

    AbstractStringProperty rufnameProperty = personendatenProperties.getRufnameProperty();
    if (formBuilder.containsProperty(rufnameProperty)) {
      formBuilder.selectProperty(rufnameProperty).withRequired(rufnameProperty.isRequired() && rufnameProperty.hasValue());
    }

    AbstractDateProperty geburtsdatumProperty = personendatenProperties.getGeburtsdatumProperty();
    if (formBuilder.containsProperty(geburtsdatumProperty)) {
      formBuilder.selectProperty(geburtsdatumProperty).withRequired(geburtsdatumProperty.isRequired() && geburtsdatumProperty.hasValue());
    }
  }

  protected void addVerifiedAnschriftProperties(FormBuilder formBuilder, PersonenregisterPersonendatenMatcher matcher, boolean matcherEnabled, Personendaten personendaten, Anschrift anschrift,
      PersonenregisterAnschrift personenregisterAnschrift) {

    if (anschrift == null /*ELECTDD-698 DD Phänomen?*/) {
      LOG.warn("Anschrift fehlt: " + personendaten);
    } else {
      AnschriftProperties anschriftProperties = anschrift.getProperties();

      formBuilder.addProperty(anschriftProperties.getAnschriftArtProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchAnschriftArt(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getStrasseProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchStrasse(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getHausnummerProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchHausnummer(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getHausnummerzusatzProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchHausnummerzusatz(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getWohnungsnummerProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchWohnungsnummer(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getPlzProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchPlz(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getOrtProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchOrt(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getOrtsteilProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchOrtsteil(personendaten, anschrift, personenregisterAnschrift));
      }

      formBuilder.addProperty(anschriftProperties.getZustellanweisungProperty());
      if (matcherEnabled) {
        tryAddVerificationMessage(formBuilder, matcher.matchZustellanweisung(personendaten, anschrift, personenregisterAnschrift));
      }

      setVerifiedAnschriftPropertiesRequired(formBuilder, personendaten, anschrift);
    }
  }

  protected void setVerifiedAnschriftPropertiesRequired(FormBuilder formBuilder, Personendaten personendaten, Anschrift anschrift) {
    anschriftViewFormBuilder.setPersonendatenAnschriftPropertiesRequired(formBuilder, personendaten, anschrift);
  }

  public void addProperties(FormBuilder formBuilder, PersonenregisterPersonendaten personenregisterPersonendaten) {
    PersonenregisterAnschrift personenregisterAnschrift = fixNullToEmptyPersonenregisterAnschrift(personenregisterPersonendaten);

    addPersonenregisterPersonendatenProperties(formBuilder, personenregisterPersonendaten);
    addPersonenregisterAnschriftProperties(formBuilder, personenregisterPersonendaten, personenregisterAnschrift);

    if (isPropertiesGlobalReadonlySupported()) {
      // NOTE, dass dieser Aufruf verhindert, dass die einzelnen Übernehmen-Button angezeigt werden.
      formBuilder.globalReadonly();
    }
  }

  // ELECT-8262
  private void setVerifiedAnschriftPropertiesOptionalIfUndefined(FormBuilder formBuilder, Personendaten personendaten, Anschrift anschrift) {
    // Do nothing...
  }

  protected void addPersonenregisterPersonendatenProperties(FormBuilder formBuilder, PersonenregisterPersonendaten personenregisterPersonendaten) {
    PersonenregisterPersonendatenProperties properties = personenregisterPersonendaten.getProperties();

    formBuilder.addProperty(properties.getOrdnungsmerkmalProperty());

    formBuilder.addProperty(properties.getAnredeProperty());
    formBuilder.addProperty(properties.getTitelProperty());

    formBuilder.addProperty(properties.getFamiliennameBestandteilProperty());
    formBuilder.addProperty(properties.getFamiliennameProperty());

    formBuilder.addProperty(properties.getRufnameProperty());
    formBuilder.addProperty(properties.getVornamenProperty());

    formBuilder.addProperty(properties.getGeburtsdatumProperty());
    formBuilder.addProperty(properties.getGeschlechtProperty());

    List<PersonenregisterPersonendatenProperties.NameOrCodeStaatsangehoerigkeitProperty> staatsangehoerigkeitProperties = getStaatsangehoerigkeitProperties(properties);

    for (PersonenregisterPersonendatenProperties.NameOrCodeStaatsangehoerigkeitProperty property : staatsangehoerigkeitProperties) {
      Staat staatsangehoerigkeit = tryFindStaatsangehoerigkeit(property.getCodeStaatsangehoerigkeit());

      if (staatsangehoerigkeit != null) {
        property.setNameStaatsangehoerigkeit(staatsangehoerigkeit.getNameStaatsangehoerigkeit());
      }

      formBuilder.addProperty(property);

      if (staatsangehoerigkeitProperties.indexOf(property) > 0) {
        // NOTE, dass NUR FÜR DIE ERSTE Staatsangehörigkeit ein Label und ein Button zur Übernahme angezeigt werden soll!
        formBuilder.withLabel("").readonly();
      }
    }

    formBuilder.addProperty(properties.getWahlrechtsausschlussProperty());
  }

  protected List<PersonenregisterPersonendatenProperties.NameOrCodeStaatsangehoerigkeitProperty> getStaatsangehoerigkeitProperties(PersonenregisterPersonendatenProperties properties) {
    return properties.getNameOrCodeStaatsangehoerigkeitProperties();
  }

  protected void addPersonenregisterAnschriftProperties(FormBuilder formBuilder, PersonenregisterPersonendaten personenregisterPersonendaten, PersonenregisterAnschrift personenregisterAnschrift) {
    PersonenregisterAnschriftProperties anschriftProperties = personenregisterAnschrift.getProperties();

    formBuilder.addProperty(anschriftProperties.getAnschriftArtProperty());

    formBuilder.addProperty(anschriftProperties.getStrasseProperty());
    formBuilder.addProperty(anschriftProperties.getHausnummerProperty());
    formBuilder.addProperty(anschriftProperties.getHausnummerzusatzProperty());
    formBuilder.addProperty(anschriftProperties.getWohnungsnummerProperty());

    formBuilder.addProperty(anschriftProperties.getPlzProperty());
    formBuilder.addProperty(anschriftProperties.getOrtProperty());
    formBuilder.addProperty(anschriftProperties.getOrtsteilProperty());

    formBuilder.addProperty(anschriftProperties.getZustellanweisungProperty());
  }

  protected void tryAddVerificationMessage(FormBuilder formBuilder, PersonenregisterPersonendatenMatcherResult matcherResult) {
    String styleClasses = "";

    if (matcherResult.isAttributeToMatchAutomatischUebernehmbar()) {
      styleClasses += " attributeToMatchAutomatischUebernehmbar";

      formBuilder.withTooltip(getVerificationMessageAttributeToMatchAutomatischUebernehmbar());
    }

    if (matcherResult.isValueVerschieden()) {
      styleClasses += " matchArtVerschieden";

      if (matcherResult.isAttributeToMatchAutomatischUebernehmbar()) {
        withVerificationMessage(formBuilder, FacesMessage.SEVERITY_ERROR, getVerificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar());
      } else {
        withVerificationMessage(formBuilder, FacesMessage.SEVERITY_WARN, getVerificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar());
      }
    } else if (matcherResult.isValueAehnlich()) {
      styleClasses += " matchArtAehnlich";

      withVerificationMessage(formBuilder, FacesMessage.SEVERITY_INFO, getVerificationMessageValueAehnlich());
    }

    if (isNotBlank(styleClasses)) {
      formBuilder.withStyleClass(styleClasses);
    }
  }

  protected void withVerificationMessage(FormBuilder formBuilder, Severity severity, String message) {
    if (FacesMessage.SEVERITY_FATAL.equals(severity) || FacesMessage.SEVERITY_ERROR.equals(severity)) {
      formBuilder.withErrorMessage(message);
    } else if (FacesMessage.SEVERITY_WARN.equals(severity)) {
      formBuilder.withWarningMessage(message);
    } else {
      formBuilder.withInfoMessage(message);
    }
  }

  private String getVerificationMessageAttributeToMatchAutomatischUebernehmbar() {
    if (isBlank(verificationMessageAttributeToMatchAutomatischUebernehmbar)) {
      verificationMessageAttributeToMatchAutomatischUebernehmbar = createVerificationMessageAttributeToMatchAutomatischUebernehmbar();
    }

    return verificationMessageAttributeToMatchAutomatischUebernehmbar;
  }

  protected String createVerificationMessageAttributeToMatchAutomatischUebernehmbar() {
    return getMessage("personen.konflikt.personenregister.abgleich.ATTRIBUTE_TO_MATCH_AUTOMATISCH_UEBERNEHMBAR_detail", personenregisterMeta.getKurznameEinzahlMessage());
  }

  private String getVerificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar() {
    if (isBlank(verificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar)) {
      verificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar = createVerificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar();
    }

    return verificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar;
  }

  protected String createVerificationMessageValueVerschiedenAttributeToMatchAutomatischUebernehmbar() {
    return createVerificationMessageValueVerschieden();
  }

  private String getVerificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar() {
    if (isBlank(verificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar)) {
      verificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar = createVerificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar();
    }

    return verificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar;
  }

  protected String createVerificationMessageValueVerschiedenAttributeToMatchNotAutomatischUebernehmbar() {
    return createVerificationMessageValueVerschieden();
  }

  protected String createVerificationMessageValueVerschieden() {
    return getMessage("personen.konflikt.personenregister.abgleich.VALUE_VERSCHIEDEN_detail", personenregisterMeta.getKurznameEinzahlMessage());
  }

  private String getVerificationMessageValueAehnlich() {
    if (isBlank(verificationMessageValueAehnlich)) {
      verificationMessageValueAehnlich = createVerificationMessageValueAehnlich();
    }

    return verificationMessageValueAehnlich;
  }

  protected String createVerificationMessageValueAehnlich() {
    return getMessage("personen.konflikt.personenregister.abgleich.VALUE_AEHNLICH_detail", personenregisterMeta.getKurznameEinzahlMessage());
  }

  private PersonenregisterAnschrift fixNullToEmptyPersonenregisterAnschrift(PersonenregisterPersonendaten personenregisterPersonendaten) {
    if (personenregisterPersonendaten != null) {
      return personenregisterPersonendaten.getAnschrift();
    }

    return new PersonenregisterAnschrift(AnschriftArt.UNBEKANNT);
  }

  protected List<StaatsangehoerigkeitProperty> getStaatsangehoerigkeitPropertiesOrDefault(Personendaten personendaten, PersonenregisterPersonendaten personenregisterPersonendaten) {
    List<Staat> values = findAllStaatsangehoerigkeiten();

    List<StaatsangehoerigkeitProperty> result = new ArrayList<>();

    List<Staat> staatsangehoerigkeitenSorted = personendaten.getStaatsangehoerigkeitenSorted();

    for (int i = 0; i < staatsangehoerigkeitenSorted.size(); i++) {
      result.add(new StaatsangehoerigkeitProperty(i, personendaten, staatsangehoerigkeitenSorted.get(i), values));
    }

    if (personenregisterPersonendaten != null) {
      int personenregisterStaatsangehoerigkeitenCount = personenregisterPersonendaten.getStaatsangehoerigkeiten().size();

      if (personenregisterStaatsangehoerigkeitenCount > result.size()) {
        for (int i = result.size(); i < personenregisterStaatsangehoerigkeitenCount; i++) {
          result.add(new StaatsangehoerigkeitProperty(i, personendaten, null, values));
        }
      }
    }

    if (result.isEmpty()) {
      result.add(new StaatsangehoerigkeitProperty(0, personendaten, null, values));
    }

    return result;
  }

  @Override
  public Collection<Class< ? extends Property>> getPersonenregisterPropertiesUebernommen(Personendaten personendaten) {
    Collection<Class< ? extends Property>> result = new ArrayList<>();

    result.addAll(personendatenViewFormBuilder.getDefaultPersonenregisterPropertiesUebernommen(personendaten));
    result.addAll(anschriftViewFormBuilder.getDefaultPersonenregisterPropertiesUebernommen(personendaten));

    return result;
  }
}
