HLTech / judge-d

@Slf4j

@RequiredArgsConstructor

public class JudgeDApplicationService {

    private final EnvironmentRepository environmentRepository;

    private final ServiceContractsRepository serviceContractsRepository;

    private final List<InterfaceContractValidator<?, ?>> validators;

    public void overwriteEnvironment(String environmentName, String agentSpace, Set<ServiceId> serviceIds) {

        String space = firstNonNull(agentSpace, DEFAULT_NAMESPACE);

        Environment environment = environmentRepository.find(environmentName)

            .orElse(new Environment(environmentName, new HashSet<>()));

        Set<String> supportedSpaces = ImmutableSet.<String>builder()

            .addAll(environment.getSpaceNames())

            .add(space)

            .build();

        Set<Space> spaces = new HashSet<>();

        for (String spaceName : supportedSpaces) {

            if (space.equals(spaceName)) {

                spaces.add(new Space(spaceName, serviceIds));

            } else {

                spaces.add(new Space(spaceName, environment.getServices(spaceName)));

            }

        }

        environmentRepository.persist(new Environment(environmentName, spaces));

    }

    public Collection<EnvironmentValidatorResult> validateServiceAgainstEnvironments(

        ServiceId serviceId,

        List<String> environments) {

        ServiceContracts validatedServiceContracts = this.serviceContractsRepository.findOne(serviceId)

            .orElseThrow(ResourceNotFoundException::new);

        return this.validators.stream()

            .map(validator ->

                validateServiceAgainstEnvironments(

                    validatedServiceContracts,

                    environments,

                    validator

                ))

            .collect(toList());

    }

    public Multimap<ServiceId, EnvironmentValidatorResult> validatedServicesAgainstEnvironment(

        List<ServiceId> serviceIds,

        String environment) {

        List<ServiceContracts> validatedServiceContracts = serviceIds.stream()

            .map(serviceContractsRepository::findOne)

            .map(o -> o.orElseThrow(RequestValidationException::new))

            .collect(toList());

        Multimap<ServiceId, EnvironmentValidatorResult> validationResults = HashMultimap.create();

        this.validators

            .forEach(validator ->

                validatedServicesAgainstEnvironment(

                    validatedServiceContracts,

                    environment,

                    validator

                )

                    .forEach(validationResults::put)

            );

        return validationResults;

    }

    private <C, E> EnvironmentValidatorResult validateServiceAgainstEnvironments(

        ServiceContracts contractsToValidate,

        List<String> environments,

        InterfaceContractValidator<C, E> validator

    ) {

        List<ServiceContracts> environmentContracts = environments.stream()

            .flatMap(envName -> getServicesIds(envName).stream())

            .map(this.serviceContractsRepository::findOne)

            .filter(Optional::isPresent)

            .map(Optional::get)

            .collect(toList());

        return getValidatorResult(contractsToValidate, environmentContracts, validator);

    }

    private <C, E> Map<ServiceId, EnvironmentValidatorResult> validatedServicesAgainstEnvironment(

        List<ServiceContracts> contractToValidate,

        String env,

        InterfaceContractValidator<C, E> validator

    ){

        // find contracts on given env

        List<ServiceContracts> environmentContracts = getServicesIds(env).stream()

            .map(service -> this.serviceContractsRepository.findOne(new ServiceId(service.getName(), service.getVersion())))

            .filter(Optional::isPresent)

            .map(Optional::get)

            .collect(toList());

        log.info("checking how " +

            "["+ Joiner.on(", ").join(contractToValidate.stream().map(sc -> sc.getId().toString()).collect(toList()))+"] will impact the env " +

            "["+ Joiner.on(", ").join(environmentContracts.stream().map(sc -> sc.getId().toString()).collect(toList()))+"]");

        // replace environment contracts with validated ones

        contractToValidate.forEach(validatedContract -> {

            environmentContracts.removeIf(serviceContracts -> serviceContracts.getName().equals(validatedContract.getId().getName()));

            environmentContracts.add(validatedContract);

        });

        log.info("after the deployment env will contain: ["+Joiner.on(", ").join(environmentContracts.stream().map(sc -> sc.getId().toString()).collect(toList()))+"]");

        Map<ServiceId, EnvironmentValidatorResult> hashMap = Maps.newHashMap();

        for (ServiceContracts sc : contractToValidate) {

            hashMap.put(sc.getId(), getValidatorResult(sc, environmentContracts, validator));

        }

        return hashMap;

    }

    private Set<ServiceId> getServicesIds(String environmentName) {

        var environment = this.environmentRepository.find(environmentName)

            .orElseThrow(ResourceNotFoundException::new);

        return environment.getAllServices();