package com.airlock.iam.admin.infrastructure.mapper.analytics;

import com.airlock.iam.admin.domain.model.analytics.Analytics;
import com.airlock.iam.admin.domain.model.analytics.ConfigAnalytics;
import com.airlock.iam.admin.domain.model.analytics.LicenseAnalytics;
import com.airlock.iam.admin.domain.model.analytics.StructuredLicenseAnalytics;
import com.airlock.iam.admin.domain.model.analytics.UsageAnalytics;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class AnalyticsMapperImpl implements AnalyticsMapper {
   @Override
   public AnalyticsDocument map(Analytics data) {
      if (data == null) {
         return null;
      }

      AnalyticsDocument.AnalyticsDocumentBuilder analyticsDocument = AnalyticsDocument.builder();
      analyticsDocument.iamVersion(data.iamVersion());
      analyticsDocument.license(this.map(data.license()));
      analyticsDocument.userCount(data.userCount());
      analyticsDocument.usageAnalyticsEnabled(data.usageAnalyticsEnabled());
      analyticsDocument.runningInDocker(data.runningInDocker());
      analyticsDocument.createdAt(AnalyticsMapper.map(data.createdAt()));
      analyticsDocument.usageData(this.map(AnalyticsMapper.unwrapOptional(data.usageData())));
      return analyticsDocument.build();
   }

   @Override
   public LicenseDocument map(LicenseAnalytics data) {
      if (data == null) {
         return null;
      }

      LicenseDocument.LicenseDocumentBuilder licenseDocument = LicenseDocument.builder();
      licenseDocument.structured(this.map(AnalyticsMapper.unwrapOptional(data.structured())));
      licenseDocument.licenseText(AnalyticsMapper.unwrapOptional(data.licenseText()));
      return licenseDocument.build();
   }

   @Override
   public StructuredLicenseDocument map(StructuredLicenseAnalytics data) {
      if (data == null) {
         return null;
      }

      StructuredLicenseDocument.StructuredLicenseDocumentBuilder structuredLicenseDocument = StructuredLicenseDocument.builder();
      structuredLicenseDocument.owner(AnalyticsMapper.unwrapOptional(data.owner()));
      structuredLicenseDocument.issuedOn(AnalyticsMapper.unwrapOptional(data.issuedOn()));
      structuredLicenseDocument.validFrom(AnalyticsMapper.unwrapOptional(data.validFrom()));
      structuredLicenseDocument.validUntil(AnalyticsMapper.unwrapOptional(data.validUntil()));
      structuredLicenseDocument.environment(AnalyticsMapper.unwrapOptional(data.environment()));
      structuredLicenseDocument.licensedUsers(AnalyticsMapper.unwrapOptional(data.licensedUsers()));
      structuredLicenseDocument.licensedInstances(AnalyticsMapper.unwrapOptional(data.licensedInstances()));
      Set<String> set = data.licensedTags();
      if (set != null) {
         structuredLicenseDocument.licensedTags(new ArrayList<>(set));
      }

      Set<String> set1 = data.bundles();
      if (set1 != null) {
         structuredLicenseDocument.bundles(new ArrayList<>(set1));
      }

      Set<String> set2 = data.licensedMac48Addresses();
      if (set2 != null) {
         structuredLicenseDocument.licensedMac48Addresses(new ArrayList<>(set2));
      }

      return structuredLicenseDocument.build();
   }

   @Override
   public UsageDataDocument map(UsageAnalytics data) {
      if (data == null) {
         return null;
      }

      UsageDataDocument.UsageDataDocumentBuilder usageDataDocument = UsageDataDocument.builder();
      usageDataDocument.config(this.configAnalyticsToConfigDocument(data.config()));
      return usageDataDocument.build();
   }

   protected ConfigDocument configAnalyticsToConfigDocument(ConfigAnalytics configAnalytics) {
      if (configAnalytics == null) {
         return null;
      }

      ConfigDocument.ConfigDocumentBuilder configDocument = ConfigDocument.builder();
      Map<?, ?> map = configAnalytics.configMap();
      if (map != null) {
         configDocument.configMap(new LinkedHashMap<>(map));
      }

      return configDocument.build();
   }
}