/*
 *******************************************************************************
 * Copyright (c) 2019 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************
 */
package org.eclipse.openk.contactbasedata.support;

import org.eclipse.openk.contactbasedata.constants.Constants;
import org.eclipse.openk.contactbasedata.model.KeyCloakUser;
import org.eclipse.openk.contactbasedata.model.RefAddressType;
import org.eclipse.openk.contactbasedata.model.RefCommunicationType;
import org.eclipse.openk.contactbasedata.model.RefPersonType;
import org.eclipse.openk.contactbasedata.model.RefSalutation;
import org.eclipse.openk.contactbasedata.model.TblAddress;
import org.eclipse.openk.contactbasedata.model.TblAssignmentModulContact;
import org.eclipse.openk.contactbasedata.model.TblCommunication;
import org.eclipse.openk.contactbasedata.model.TblCompany;
import org.eclipse.openk.contactbasedata.model.TblContact;
import org.eclipse.openk.contactbasedata.model.TblContactPerson;
import org.eclipse.openk.contactbasedata.model.TblExternalPerson;
import org.eclipse.openk.contactbasedata.model.TblInternalPerson;
import org.eclipse.openk.contactbasedata.model.Version;
import org.eclipse.openk.contactbasedata.model.VwDetailedContact;
import org.eclipse.openk.contactbasedata.viewmodel.AddressDto;
import org.eclipse.openk.contactbasedata.viewmodel.AddressTypeDto;
import org.eclipse.openk.contactbasedata.viewmodel.AssignmentModulContactDto;
import org.eclipse.openk.contactbasedata.viewmodel.CommunicationDto;
import org.eclipse.openk.contactbasedata.viewmodel.CommunicationTypeDto;
import org.eclipse.openk.contactbasedata.viewmodel.CompanyDto;
import org.eclipse.openk.contactbasedata.viewmodel.ContactDto;
import org.eclipse.openk.contactbasedata.viewmodel.ContactPersonDto;
import org.eclipse.openk.contactbasedata.viewmodel.ExternalPersonDto;
import org.eclipse.openk.contactbasedata.viewmodel.InternalPersonDto;
import org.eclipse.openk.contactbasedata.viewmodel.LdapUser;
import org.eclipse.openk.contactbasedata.viewmodel.PersonTypeDto;
import org.eclipse.openk.contactbasedata.viewmodel.SalutationDto;
import org.eclipse.openk.contactbasedata.viewmodel.VersionDto;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;

import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class MockDataHelper {

    public static Version mockVersion() {
        Version version = new Version();
        version.setId(4711L);
        version.setVersion("db-version_mock_1");
        return version;
    }

    public static VersionDto mockVersionDto() {
        VersionDto versionDto = new VersionDto();
        versionDto.setBackendVersion("660");
        versionDto.setDbVersion("550");
        return versionDto;
    }

    public static VwDetailedContact mockVDetailedContact() {
        VwDetailedContact contact = new VwDetailedContact();
        contact.setId(1L);
        contact.setUuid(UUID.randomUUID());
        contact.setName("Haferkamp");
        return contact;
    }

    public static Page<VwDetailedContact> mockVDetailedContactPage() {
        VwDetailedContact v1 = mockVDetailedContact();
        VwDetailedContact v2 = mockVDetailedContact();
        v2.setId(2L);
        v2.setName("Strofanov");
        List<VwDetailedContact> list = Arrays.asList(v1, v2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static TblExternalPerson mockExternalPerson() {
        TblContact c = new TblContact();
        c.setId( 3L );
        c.setContactType(Constants.CONTACT_TYPE_EXTERNAL_PERSON);
        c.setUuid(UUID.randomUUID());
        TblExternalPerson e = new TblExternalPerson();
        e.setId( 34L );
        e.setContact(c);
        e.setFirstName("Florinda");
        e.setLastName("Fieselbrink");
        e.setTitle("Dr. von und zu");
        e.setRefPersonType(mockRefPersonType());
        e.setSalutation(mockRefSalutation());
        c.setNote("Notiz am Rande");
        return e;
    }

    public static ExternalPersonDto mockExternalPersonDto() {
        ExternalPersonDto epd = new ExternalPersonDto();
        epd.setContactUuid(UUID.randomUUID());
        epd.setFirstName("Zotto");
        epd.setLastName("Briketti");
        epd.setContactType(Constants.CONTACT_TYPE_EXTERNAL_PERSON);
        epd.setTitle("Dr. von und zu");
        epd.setPersonTypeUuid(UUID.randomUUID());
        epd.setSalutationUuid(UUID.randomUUID());
        epd.setContactNote("Notiz am Rande");
        return epd;
    }

    public static Page<TblExternalPerson> mockExternalPersonPage() {
        TblExternalPerson ep1 = mockExternalPerson();
        TblExternalPerson ep2 = mockExternalPerson();
        ep2.setFirstName("Strofanov");
        ep2.getContact().setUuid(UUID.randomUUID());
        List<TblExternalPerson> list = Arrays.asList(ep1, ep2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static Page<ExternalPersonDto> mockExternalPersonDtoPage() {
        ExternalPersonDto ep1 = mockExternalPersonDto();
        ExternalPersonDto ep2 = mockExternalPersonDto();
        ep2.setFirstName("Strofanov");
        ep2.setContactUuid(UUID.randomUUID());
        List<ExternalPersonDto> list = Arrays.asList(ep1, ep2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }
    public static RefSalutation mockRefSalutation() {
        RefSalutation sal = new RefSalutation();
        sal.setId(1L);
        sal.setUuid(UUID.randomUUID());
        sal.setDescription("Ave Marcus Antonius");
        sal.setType("Maitre");
        return sal;
    }

    public static SalutationDto mockSalutationDto() {
        SalutationDto sal = new SalutationDto();
        sal.setUuid(UUID.randomUUID());
        sal.setDescription("Ave Caesar");
        sal.setType("Maitre");
        return sal;
    }

    public static List<SalutationDto> mockSalutationsDtos() {
        List<SalutationDto> dtos = new LinkedList<>();
        dtos.add( mockSalutationDto() );
        SalutationDto sd2 = mockSalutationDto();
        sd2.setType("Magistra");
        sd2.setDescription("Ave Cleopatra");
        dtos.add( sd2 );
        return dtos;
    }

    public static List<RefSalutation> mockRefSalutations() {
        List<RefSalutation> refs = new LinkedList<>();
        refs.add( mockRefSalutation() );
        RefSalutation sd2 = mockRefSalutation();
        sd2.setType("Magistra");
        sd2.setDescription("Ave Messalina");
        refs.add( sd2 );
        return refs;
    }

    public static RefPersonType mockRefPersonType() {
        RefPersonType refPersonType = new RefPersonType();
        refPersonType.setId(1L);
        refPersonType.setUuid(UUID.randomUUID());
        refPersonType.setDescription("Ehrenmann");
        refPersonType.setType("ElCapitan");
        return refPersonType;
    }

    public static PersonTypeDto mockPersonTypeDto() {
        PersonTypeDto personTypeDto = new PersonTypeDto();
        personTypeDto.setUuid(UUID.randomUUID());
        personTypeDto.setDescription("Ehrenmann");
        personTypeDto.setType("ElCapitan");
        return personTypeDto;
    }

    public static List<PersonTypeDto> mockPersonTypesDtos() {
        List<PersonTypeDto> dtos = new LinkedList<>();
        dtos.add( mockPersonTypeDto() );
        PersonTypeDto sd2 = mockPersonTypeDto();
        sd2.setType("Gutmensch");
        sd2.setDescription("Zu guter Mensch");
        dtos.add( sd2 );
        return dtos;
    }

    public static List<RefPersonType> mockRefPersonTypes() {
        List<RefPersonType> refs = new LinkedList<>();
        refs.add( mockRefPersonType() );
        RefPersonType sd2 = mockRefPersonType();
        sd2.setType("Gutmensch");
        sd2.setDescription("Zu guter Mensch");
        refs.add( sd2 );
        return refs;
    }

    public static RefAddressType mockRefAddressType() {
        RefAddressType refAddressType = new RefAddressType();
        refAddressType.setId(1L);
        refAddressType.setUuid(UUID.randomUUID());
        refAddressType.setDescription("Zweitwohnsitz");
        refAddressType.setType("Nebenadresse");
        return refAddressType;
    }

    public static AddressTypeDto mockAddressTypeDto() {
        AddressTypeDto addressTypeDto = new AddressTypeDto();
        addressTypeDto.setUuid(UUID.randomUUID());
        addressTypeDto.setDescription("Zweitwohnsitz");
        addressTypeDto.setType("Nebenadresse");
        return addressTypeDto;
    }

    public static List<AddressTypeDto> mockAddressTypesDtos() {
        List<AddressTypeDto> dtos = new LinkedList<>();
        dtos.add( mockAddressTypeDto() );
        AddressTypeDto sd2 = mockAddressTypeDto();
        sd2.setType("Mülltonne");
        sd2.setDescription("Drittwohnsitz");
        dtos.add( sd2 );
        return dtos;
    }

    public static List<RefAddressType> mockRefAddressTypes() {
        List<RefAddressType> refs = new LinkedList<>();
        refs.add( mockRefAddressType() );
        RefAddressType sd2 = mockRefAddressType();
        sd2.setType("Mülltonne");
        sd2.setDescription("Drittwohnsitz");
        refs.add( sd2 );
        return refs;
    }

    public static TblAddress mockTblAddress(){
        TblAddress tblAddress = new TblAddress();

        tblAddress.setCommunity("Fischland");
        tblAddress.setCommunitySuffix("-");
        tblAddress.setHousenumber("13");
        tblAddress.setId(5L);
        tblAddress.setIsMainAddress(false);
        tblAddress.setLatitude("52N");
        tblAddress.setLongitude("2E");
        tblAddress.setNote("-");
        tblAddress.setPostcode("67890");
        tblAddress.setRefAddressType(mockRefAddressType());
        tblAddress.setStreet("Moosrosenweg");
        tblAddress.setTblContact(mockTblContact());
        tblAddress.setUrlMap("-");
        tblAddress.setUuid(UUID.fromString("f34dfffc-314a-11ea-978f-2e728ce88125"));
        tblAddress.setWgs_84_zone("-");

        return tblAddress;
    }

    public static AddressDto mockAddressDto(){
        AddressDto addressDto = new AddressDto();

        addressDto.setCommunity("Fischland");
        addressDto.setCommunitySuffix("-");
        addressDto.setHousenumber("13");
        addressDto.setIsMainAddress(false);
        addressDto.setLatitude("52N");
        addressDto.setLongitude("2E");
        addressDto.setNote("-");
        addressDto.setPostcode("67890");
        addressDto.setAddressTypeUuid(mockRefAddressType().getUuid());
        addressDto.setStreet("Moosrosenweg");
        addressDto.setContactUuid(UUID.randomUUID());
        addressDto.setUrlMap("-");
        addressDto.setUuid(UUID.fromString("f34dfffc-314a-11ea-978f-2e728ce88125"));
        addressDto.setWgs84Zone("-");

        addressDto.setContactUuid(UUID.randomUUID());

        return addressDto;
    }

    public static List<AddressDto> mockAddressDtoList(){

        List<AddressDto> list = new ArrayList<>();

        AddressDto addressDto1 = mockAddressDto();

        AddressDto addressDto2 = new AddressDto();
        addressDto2.setCommunity("Pusemuckel");
        addressDto2.setCommunitySuffix("-");
        addressDto2.setHousenumber("17");
        addressDto2.setIsMainAddress(false);
        addressDto2.setLatitude("51N");
        addressDto2.setLongitude("3E");
        addressDto2.setNote("-");
        addressDto2.setPostcode("87655");
        //addressDto.setRefAddressType();
        addressDto2.setStreet("Birkenweg");
        //addressDto.setTblContact();
        addressDto2.setUrlMap("-");
        addressDto2.setUuid(UUID.fromString("7dff534c-314d-11ea-978f-2e728ce88125"));
        addressDto2.setWgs84Zone("-");

        list.add(addressDto1);
        list.add(addressDto2);

        return list;
    }

    public static List<TblAddress> mockTblAddressList(){

        List<TblAddress> list = new ArrayList<>();

        TblAddress tblAddressDto1 = mockTblAddress();

        TblAddress tblAddressDto2 = new TblAddress();
        tblAddressDto2.setCommunity("Pusemuckel");
        tblAddressDto2.setCommunitySuffix("-");
        tblAddressDto2.setHousenumber("17");
        tblAddressDto2.setIsMainAddress(false);
        tblAddressDto2.setLatitude("51N");
        tblAddressDto2.setLongitude("3E");
        tblAddressDto2.setNote("-");
        tblAddressDto2.setPostcode("87655");
        tblAddressDto2.setRefAddressType(mockRefAddressType());
        tblAddressDto2.setStreet("Birkenweg");
        //tblAddressDto2.setTblContact();
        tblAddressDto2.setUrlMap("-");
        tblAddressDto2.setUuid(UUID.fromString("7dff534c-314d-11ea-978f-2e728ce88125"));
        tblAddressDto2.setWgs_84_zone("-");

        list.add(tblAddressDto1);
        list.add(tblAddressDto2);

        return list;
    }

    public static RefCommunicationType mockRefCommunicationType(){
        RefCommunicationType communicationType = new RefCommunicationType();
        communicationType.setId(2L);
        communicationType.setUuid(UUID.randomUUID());
        communicationType.setDescription("Fax");
        communicationType.setType("Fax");

        return communicationType;
    }

    public static CommunicationTypeDto mockCommunicationTypeDto(){
        CommunicationTypeDto communicationTypeDto = new CommunicationTypeDto();
        communicationTypeDto.setUuid(UUID.randomUUID());
        communicationTypeDto.setDescription("Fax");
        communicationTypeDto.setType("Fax");
        communicationTypeDto.setEditable(true);
        communicationTypeDto.setMappingLdap(false);

        return communicationTypeDto;
    }

    public static List<CommunicationTypeDto> mockCommunicationTypeDtoList(){

        CommunicationTypeDto ctDto1 = mockCommunicationTypeDto();
        CommunicationTypeDto ctDto2 = mockCommunicationTypeDto();
        ctDto2.setDescription("Mobil");
        ctDto2.setType("Mobil");
        CommunicationTypeDto ctDto3 = mockCommunicationTypeDto();
        ctDto3.setDescription("Pers�nlich");
        ctDto3.setType("Pers�nlich");

        List<CommunicationTypeDto> listCtDto = new ArrayList<>();
        listCtDto.add(ctDto1);
        listCtDto.add(ctDto2);
        listCtDto.add(ctDto3);

        return listCtDto;
    }

    public static List<RefCommunicationType> mockRefCommunicationTypeList(){

        RefCommunicationType ct1 = mockRefCommunicationType();
        RefCommunicationType ct2 = mockRefCommunicationType();
        ct2.setDescription("Mobil");
        ct2.setType("Mobil");
        RefCommunicationType ct3 = mockRefCommunicationType();
        ct3.setDescription("E-Mail");
        ct3.setType("E-Mail");
        ct3.setTypeEmail(true);

        List<RefCommunicationType> listCt = new ArrayList<>();
        listCt.add(ct1);
        listCt.add(ct2);
        listCt.add(ct3);

        return listCt;
    }

    public static TblInternalPerson mockInternalPerson() {
        TblContact c = new TblContact();
        c.setId( 10L );
        c.setContactType(Constants.CONTACT_TYPE_INTERNAL_PERSON);
        c.setUuid(UUID.randomUUID());
        TblInternalPerson i = new TblInternalPerson();
        i.setId( 12L );
        i.setContact(c);
        i.setFirstName("Wolfi");
        i.setLastName("Weinbrenner");
        i.setTitle("Freiherr");
        i.setDepartment("Forschung");
        i.setUidIdent("111-777");
        i.setUserRef("WWEINB");
        i.setRefPersonType(mockRefPersonType());
        i.setSalutation(mockRefSalutation());
        c.setNote("Teilzeit");
        return i;
    }

    public static InternalPersonDto mockInternalPersonDto() {
        InternalPersonDto ipd = new InternalPersonDto();
        ipd.setContactUuid(UUID.randomUUID());
        ipd.setFirstName("Hella");
        ipd.setLastName("Wahnsinn");
        ipd.setContactType(Constants.CONTACT_TYPE_INTERNAL_PERSON);
        ipd.setTitle("Mrs.");
        ipd.setDepartment("Beschwerdemanagement");
        ipd.setUid("222-888");
        ipd.setUserRef("HWAHNS");
        ipd.setPersonTypeUuid(UUID.randomUUID());
        ipd.setSalutationUuid(UUID.randomUUID());
        ipd.setContactNote("Vorsicht");
        return ipd;
    }

    public static Page<InternalPersonDto> mockInternalPersonDtoPage(){

        InternalPersonDto ip1 = mockInternalPersonDto();

        InternalPersonDto ip2 = new InternalPersonDto();
        ip2.setContactUuid(UUID.randomUUID());
        ip2.setFirstName("Fritz");
        ip2.setLastName("Alter");
        ip2.setContactType(Constants.CONTACT_TYPE_INTERNAL_PERSON);
        ip2.setTitle("Dr.");
        ip2.setDepartment("Geschäftsführung");
        ip2.setUid("333-999");
        ip2.setUserRef("FALTER");
        ip2.setPersonTypeUuid(UUID.randomUUID());
        ip2.setSalutationUuid(UUID.randomUUID());
        ip2.setContactNote("Gründer");

        List<InternalPersonDto> list = Arrays.asList(ip1, ip2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static Page<TblInternalPerson> mockTblInternalPersonPage(){

        TblInternalPerson ip1 = mockInternalPerson();

        TblInternalPerson ip2 = new TblInternalPerson();
        ip2.setContact(new TblContact());
        ip2.getContact().setUuid(UUID.randomUUID());
        ip2.setFirstName("Fritz");
        ip2.setLastName("Alter");
        ip2.setTitle("Dr.");
        ip2.setDepartment("Geschäftsführung");
        ip2.setUidIdent("333-999");
        ip2.setUserRef("FALTER");
        ip2.getContact().setNote("Gründer");

        List<TblInternalPerson> list = Arrays.asList(ip1, ip2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static TblCompany mockCompany() {
        TblContact c = new TblContact();
        c.setId( 10L );
        c.setContactType(Constants.CONTACT_TYPE_COMPANY);
        c.setUuid(UUID.randomUUID());
        TblCompany tblCompany = new TblCompany();
        tblCompany.setId( 12L );
        tblCompany.setContact(c);
        tblCompany.setCompanyName("Kuemmelbrot");
        tblCompany.setCompanyType("GmbH");
        c.setNote("insolvent");
        return tblCompany;
    }

    public static CompanyDto mockCompanyDto() {
        CompanyDto tblCompany = new CompanyDto();
        tblCompany.setContactUuid(UUID.randomUUID());
        tblCompany.setCompanyName("Kuemmelbrot");
        tblCompany.setCompanyType("GmbH");
        tblCompany.setContactType(Constants.CONTACT_TYPE_COMPANY);

        tblCompany.setContactNote("Vorsicht");
        return tblCompany;
    }

    public static Page<TblCompany> mockCompanyPage(){

        TblCompany com1 = mockCompany();

        TblCompany com2 = mockCompany();
        com2.setCompanyName("Sputnik 2000");
        com2.setCompanyType("AG");

        List<TblCompany> list = Arrays.asList(com1, com2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static Page<CompanyDto> mockCompanyDtoPage(){

        CompanyDto com1 = mockCompanyDto();

        CompanyDto com2 = new CompanyDto();
        com2.setContactUuid(UUID.randomUUID());
        com2.setCompanyName("Sputnik 2000");
        com2.setCompanyType("AG");
        com2.setContactType(Constants.CONTACT_TYPE_COMPANY);
        com2.setContactNote("Gründer");

        List<CompanyDto> list = Arrays.asList(com1, com2);
        return new PageImpl<>(list, Pageable.unpaged(), list.size());
    }

    public static TblContactPerson mockTblContactPerson() {
        TblContactPerson cp = new TblContactPerson();
        cp.setCompany(mockCompany());
        cp.setContact(mockTblContact());
        cp.setFirstName("Prober");
        cp.setLastName("Cottwick");
        cp.setRefPersonType(mockRefPersonType());
        cp.setSalutation(mockRefSalutation());
        cp.setContact(mockTblContact());
        return cp;
    }

    public static List<TblContactPerson> mockTblContactPersons() {
        return Arrays.asList(mockTblContactPerson(), mockTblContactPerson());
    }

    public static ContactPersonDto mockContactPersonDto() {
        ContactPersonDto contactPersonDto = new ContactPersonDto();
        contactPersonDto.setCompanyContactUuid(UUID.randomUUID());
        contactPersonDto.setCompanyName("Filligri");
        contactPersonDto.setCompanyType("GmbH");
        contactPersonDto.setCompanyHrNumber("12345");
        contactPersonDto.setFirstName("Prober");
        contactPersonDto.setLastName("Cottwick");
        contactPersonDto.setCompanyType(Constants.CONTACT_TYPE_CONTACT_PERSON);
        contactPersonDto.setTitle("Prof. Dr.");
        contactPersonDto.setContactUuid(UUID.randomUUID());
        contactPersonDto.setContactType("1CP");
        contactPersonDto.setContactNote("eine Notiz");
        contactPersonDto.setSalutationUuid(UUID.randomUUID());
        contactPersonDto.setPersonTypeUuid(UUID.randomUUID());
        return contactPersonDto;
    }

    public static List<ContactPersonDto> mockContactPersonDtos(){

        ContactPersonDto  cp1 = mockContactPersonDto();

        ContactPersonDto cp2 = new ContactPersonDto();
        cp2.setContactUuid(UUID.randomUUID());
        cp2.setFirstName("Pruner");
        cp2.setLastName("Goldwick");
        cp2.setContactType(Constants.CONTACT_TYPE_CONTACT_PERSON);
        cp2.setTitle("Dr.");
        cp2.setContactNote("Gründer");

        return Arrays.asList(cp1, cp2);
    }

    public static TblContact mockTblContact(){
        TblContact tblContact = new TblContact();
        tblContact.setId(5L);
        tblContact.setUuid(UUID.randomUUID());
        tblContact.setNote("Notiz");
        tblContact.setContactType("2EP");

        return tblContact;
    }

    public static ContactDto mockContactDto(){
        ContactDto contactDto = new ContactDto();
        contactDto.setUuid(UUID.randomUUID());
        contactDto.setNote("Notiz");
        contactDto.setContactType("2EP");

        return contactDto;
    }

    public static CommunicationDto mockCommunicationDto(){
        CommunicationDto dto = new CommunicationDto();
        dto.setUuid(UUID.randomUUID());
        dto.setContactUuid(UUID.randomUUID());
        dto.setCommunicationData("030-12345678");
        dto.setCommunicationTypeDescription("Faxgerät");
        dto.setCommunicationTypeType("FAX");
        dto.setCommunicationTypeUuid(UUID.randomUUID());

        return dto;
    }


    public static List<CommunicationDto> mockCommunicationDtoList(){

        List<CommunicationDto> list = new ArrayList<>();

        CommunicationDto communicationDto1 = mockCommunicationDto();

        CommunicationDto communicationDto2 = new CommunicationDto();
        communicationDto2.setUuid(UUID.randomUUID());
        communicationDto2.setContactUuid(UUID.randomUUID());
        communicationDto2.setCommunicationData("030-456789012");
        communicationDto2.setCommunicationTypeDescription("Telefon");
        communicationDto2.setCommunicationTypeType("TEL");
        communicationDto2.setCommunicationTypeUuid(UUID.randomUUID());

        CommunicationDto communicationDto3 = new CommunicationDto();
        communicationDto3.setUuid(UUID.randomUUID());
        communicationDto3.setContactUuid(UUID.randomUUID());
        communicationDto3.setCommunicationData("030-456789012");
        communicationDto3.setCommunicationTypeDescription("Telefon");
        communicationDto3.setCommunicationTypeType("TEL");
        communicationDto3.setCommunicationTypeUuid(UUID.randomUUID());

        list.add(communicationDto1);
        list.add(communicationDto2);
        list.add(communicationDto3);

        return list;
    }

    public static TblCommunication mockTblCommunication(){
        TblCommunication tblCommunication = new TblCommunication();

        tblCommunication.setUuid(UUID.randomUUID());
        tblCommunication.setTblContact(mockTblContact());
        tblCommunication.setCommunicationData("030-55555555");
        tblCommunication.setRefCommunicationType(mockRefCommunicationType());

        return tblCommunication;
    }

    public static List<TblCommunication> mockTblCommunicationsList(){

        List<TblCommunication> list = new ArrayList<>();

        TblCommunication tblCommunicationDto1 = mockTblCommunication();

        TblCommunication tblCommunicationDto2 = new TblCommunication();
        tblCommunicationDto2.setCommunicationData("030-55555555");
        tblCommunicationDto2.setRefCommunicationType(mockRefCommunicationType());
        tblCommunicationDto2.setTblContact(mockTblContact());
        tblCommunicationDto2.setUuid(UUID.randomUUID());

        list.add(tblCommunicationDto1);
        list.add(tblCommunicationDto2);

        return list;
    }

    public static AssignmentModulContactDto mockAssignmentModulContactDto(){

        AssignmentModulContactDto assignmentDto = new AssignmentModulContactDto();

        assignmentDto.setUuid(UUID.randomUUID());
        assignmentDto.setContactUuid(UUID.randomUUID());
        assignmentDto.setAssignmentDate(Date.valueOf("2022-12-24"));
        assignmentDto.setAssignmentNote("nur für Tests");
        assignmentDto.setDeletionLockUntil(Date.valueOf("2022-12-24"));
        assignmentDto.setExpiringDate(Date.valueOf("2022-12-24"));
        assignmentDto.setModulName("Geplante Netzmassnahme");

        return assignmentDto;
    }


    public static List<AssignmentModulContactDto> mockAssignmentModulContactDtoList(){

        List<AssignmentModulContactDto> list = new ArrayList<>();

        AssignmentModulContactDto assignmentDto1 = mockAssignmentModulContactDto();

        AssignmentModulContactDto assignmentDto2 = new AssignmentModulContactDto();
        assignmentDto2.setUuid(UUID.randomUUID());
        assignmentDto2.setContactUuid(UUID.randomUUID());
        assignmentDto2.setAssignmentDate(Date.valueOf("2022-01-24"));
        assignmentDto2.setAssignmentNote("Testuser");
        assignmentDto2.setDeletionLockUntil(Date.valueOf("2022-01-24"));
        assignmentDto2.setExpiringDate(Date.valueOf("2022-01-24"));
        assignmentDto2.setModulName("Ferienkalender");

        AssignmentModulContactDto assignmentDto3 = new AssignmentModulContactDto();
        assignmentDto3.setUuid(UUID.randomUUID());
        assignmentDto3.setContactUuid(UUID.randomUUID());
        assignmentDto3.setAssignmentDate(Date.valueOf("2022-04-24"));
        assignmentDto3.setAssignmentNote("Testkoch");
        assignmentDto3.setDeletionLockUntil(Date.valueOf("2022-04-24"));
        assignmentDto3.setExpiringDate(Date.valueOf("2022-04-24"));
        assignmentDto3.setModulName("Kochdienste");

        list.add(assignmentDto1);
        list.add(assignmentDto2);
        list.add(assignmentDto3);

        return list;
    }

    public static TblAssignmentModulContact mockTblAssignmentModulContact(){

        TblAssignmentModulContact tblAssignment = new TblAssignmentModulContact();

        tblAssignment.setUuid(UUID.randomUUID());
        tblAssignment.setTblContact(mockTblContact());
        tblAssignment.setAssignmentDate(Date.valueOf("2022-12-01"));
        tblAssignment.setAssignmentNote("nur für Tests");
        tblAssignment.setDeletionLockUntil(Date.valueOf("2023-12-01"));
        tblAssignment.setExpiringDate(Date.valueOf("2024-12-01"));
        tblAssignment.setModulName("Reparaturdienste");

        return tblAssignment;
    }

    public static List<TblAssignmentModulContact> mockTblAssignmentsList(){
        List<TblAssignmentModulContact> list = new ArrayList<>();

        TblAssignmentModulContact tblAssignment  = mockTblAssignmentModulContact();

        TblAssignmentModulContact tblAssignment2 = new TblAssignmentModulContact();
        tblAssignment2.setUuid(UUID.randomUUID());
        tblAssignment2.setTblContact(mockTblContact());
        tblAssignment2.setAssignmentDate(Date.valueOf("2020-12-01"));
        tblAssignment2.setAssignmentNote("nur für Tests");
        tblAssignment2.setDeletionLockUntil(Date.valueOf("2025-12-01"));
        tblAssignment2.setExpiringDate(Date.valueOf("2030-12-01"));
        tblAssignment2.setModulName("Störungsstatistik");

        list.add(tblAssignment);
        list.add(tblAssignment2);


        return list;
    }

    public static LdapUser mockLdapUser() {
        LdapUser ldapUser = new LdapUser();
        ldapUser.setUid( UUID.randomUUID().toString() );
        ldapUser.setFirstName("Ludwig");
        ldapUser.setLastName("Lumpensammler");
        ldapUser.setMail("ll@lumpi.de");

        return ldapUser;
    }

    public static KeyCloakUser mockKeyCloakUser() {
        KeyCloakUser keyCloakUser = new KeyCloakUser();
        keyCloakUser.setUsername("ludwigL");
        keyCloakUser.setFirstName("Ludwig");
        keyCloakUser.setLastName("Lumpensammler");
        return keyCloakUser;
    }

    public static List<LdapUser> mockLdapUsers() {
        List<LdapUser> list = new ArrayList<>();
        LdapUser ldapUser2 = new LdapUser();
        ldapUser2.setUid( UUID.randomUUID().toString() );
        ldapUser2.setFirstName("Karl");
        ldapUser2.setLastName("Kleinfink");
        ldapUser2.setTelephoneNumber("99887766");
        list.add( mockLdapUser() );
        list.add( ldapUser2 );
        return list;
    }

    public static List<KeyCloakUser> mockKeycloakUsers() {
        List<KeyCloakUser> list = new ArrayList<>();
        KeyCloakUser keyCloakUser = new KeyCloakUser();
        keyCloakUser.setFirstName("Karl");
        keyCloakUser.setLastName("Kleinfink");
        keyCloakUser.setUsername("karlK");
        list.add( mockKeyCloakUser() );
        list.add( keyCloakUser );
        return list;
    }

    public static Attribute mockLdapAttribute(String value )  {
        Attribute attribute = mock( Attribute.class);
        try {
            when(attribute.get()).thenReturn(value);
        } catch (NamingException e) {
           return null;
        }
        return attribute;
    }
}