com.sportradar.unifiedodds.sdk.impl.markets.MarketDescriptionImpl Maven / Gradle / Ivy

/*
 * Copyright (C) Sportradar AG. See LICENSE for full license governing this code
 */

package com.sportradar.unifiedodds.sdk.impl.markets;

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.sportradar.unifiedodds.sdk.caching.ci.markets.MarketDescriptionCI;
import com.sportradar.unifiedodds.sdk.caching.ci.markets.MarketMappingCI;
import com.sportradar.unifiedodds.sdk.caching.ci.markets.MarketOutcomeCI;
import com.sportradar.unifiedodds.sdk.entities.markets.MarketAttribute;
import com.sportradar.unifiedodds.sdk.entities.markets.MarketDescription;
import com.sportradar.unifiedodds.sdk.entities.markets.MarketMappingData;
import com.sportradar.unifiedodds.sdk.entities.markets.OutcomeDescription;
import com.sportradar.unifiedodds.sdk.entities.markets.Specifier;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import static com.sportradar.unifiedodds.sdk.impl.UnifiedFeedConstants.FREETEXT_VARIANT_VALUE;
import static com.sportradar.unifiedodds.sdk.impl.UnifiedFeedConstants.OUTCOMETEXT_VARIANT_VALUE;

/**
 * Created on 14/06/2017.
 * // TODO @eti: Javadoc
 */
public class MarketDescriptionImpl implements MarketDescription {
    private final int id;
    private final String outcomeType;
    private final Map names;
    private final Map descriptions;
    private final List specifiers;
    private final List attributes;
    private final List groups;
    private List staticMappingsData;
    private List outcomes;
    private List mappings;
    private boolean mappingsBuilt;

    public MarketDescriptionImpl(MarketDescriptionCI cachedItem, List locales) {
        Preconditions.checkNotNull(cachedItem);
        Preconditions.checkNotNull(locales);
        Preconditions.checkArgument(!locales.isEmpty());

        id = cachedItem.getId();
        outcomeType = cachedItem.getOutcomeType();
        groups = cachedItem.getGroups();
        names = locales.stream()
                .collect(ImmutableMap.toImmutableMap(k -> k, cachedItem::getName));

        descriptions = locales.stream()
                .filter(l -> cachedItem.getCachedLocales().contains(l))
                .filter(l -> cachedItem.getDescription(l) != null)
                .collect(ImmutableMap.toImmutableMap(k -> k, cachedItem::getDescription));

        outcomes = buildOutcomes(cachedItem.getOutcomes(), locales);

        specifiers = cachedItem.getSpecifiers() == null ? null :
                cachedItem.getSpecifiers().stream()
                        .map(SpecifierImpl::new).collect(ImmutableList.toImmutableList());

        staticMappingsData = cachedItem.getMappings();

        attributes = cachedItem.getAttributes() == null ? null :
                cachedItem.getAttributes().stream()
                        .map(MarketAttributeImpl::new).collect(ImmutableList.toImmutableList());
    }

    @Override
    public int getId() {
        return id;
    }

    @Override
    public String getName(Locale locale) {
        Preconditions.checkNotNull(locale);

        return names.get(locale);
    }

    @Override
    public String getDescription(Locale locale) {
        Preconditions.checkNotNull(locale);

        return descriptions.get(locale);
    }

    @Override
    public List getOutcomes() {
        return outcomes;
    }

    @Override
    public List getSpecifiers() {
        return specifiers;
    }

    @Override
    public List getMappings() {
        if (!mappingsBuilt) {
            mappingsBuilt = true;
            mappings = staticMappingsData == null ? null :
                    staticMappingsData.stream()
                            .map(MarketMappingDataImpl::new).collect(ImmutableList.toImmutableList());
        }
        return mappings;
    }

    @Override
    public List getAttributes() {
        return attributes;
    }

    @Deprecated
    @Override
    public String getIncludesOutcomesOfType() {
        if (outcomeType == null)
            return null;

        if (outcomeType.equals(FREETEXT_VARIANT_VALUE))
            return OUTCOMETEXT_VARIANT_VALUE;
        else
            return "sr:" + outcomeType;
    }

    @Override
    public List getGroups() {
        return groups;
    }

    @Override
    public String getOutcomeType() {
        return outcomeType;
    }

    // outcomes get only merged because some of them might be static
    public void mergeOutcomes(List outcomeCIs, List locales) {
        if (this.outcomes == null) {
            this.outcomes = buildOutcomes(outcomeCIs, locales);
        } else {
            List newOutcomes = new ArrayList<>(this.outcomes);
            if (outcomeCIs != null) {
                newOutcomes.addAll(buildOutcomes(outcomeCIs, locales));
            }

            this.outcomes = ImmutableList.copyOf(newOutcomes);
        }
    }

    public List getStaticMappingsData() {
        return staticMappingsData;
    }

    public void setStaticMappingsData(List staticMappingsData) {
        this.staticMappingsData = staticMappingsData;
    }

    private static List buildOutcomes(List outcomeCis, List locales) {
        return outcomeCis == null ? Collections.emptyList() :
                outcomeCis.stream()
                        .map(o -> new OutcomeDescriptionImpl(o, locales)).collect(ImmutableList.toImmutableList());
    }
}