TargetCurrencyDefault.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
 
using AnalyzeRe.Attributes;
using AnalyzeRe.Layers;
using AnalyzeRe.Optimization;
using AnalyzeRe.Utilities;
 
namespace AnalyzeRe.APIResourceView
{
    public class TargetCurrencyDefault : ServerHasDefault
    {
        public TargetCurrencyDefault() : base(true) { }
 
        public override object GetDefaultValue(object owner)
        {
            return GetDefaultTargetCurrency(owner as IAPIResource);
        }
 
        public static string GetDefaultTargetCurrency(IAPIResource resource)
        {
            if (resource == null)
                throw new NotSupportedException("An resource instance must be " +
                    "supplied to determine what its default target currency would be.");
            if (resource is ILayerView asLayerView)
                return asLayerView.target_currency ??
                    GetDefaultFromLayer(asLayerView.layer, asLayerView.analysis_profile);
            if (resource is OptimizationView ov)
                return ov.analysis_profile.GetValue()?.exchange_rate_profile.GetValue()
                    .exchange_rate_table.GetValue().base_currency;
            if (!(resource is PortfolioView pv))
                throw new NotSupportedException("Unexpected APIResourceView type: " +
                    resource.GetType().NiceTypeName() + ". Could not determine the " +
                    "default target currency.");
            // The default is determined by the most frequent currency encountered
            IEnumerable<string> currencies;
             // If this uses a reference to a portfolio, look at its list of layers
            if (pv.portfolio != null)
                currencies = pv.portfolio.GetValue().layers
                    .Select(layer => GetDefaultFromLayer(layer.GetValue(), pv.analysis_profile));
            // Otherwise, look at the referenced list of layer_views
            else if (pv.layer_views != null && pv.layer_views.Any())
                currencies = pv.layer_views.Select(lv => lv.GetValue()).Select(GetDefaultTargetCurrency);
            else
                throw new NotSupportedException("PortfolioView is invalid.");
            // Select the currency that appears most frequently in the portfolio
            return currencies.GroupBy(ccy => ccy)
                .Select(group => new { ccy = group.Key, count = group.Count() })
                .OrderByDescending(group => group.count)
                .Select(group => group.ccy).First();
        }
 
        private static string GetDefaultFromLayer(ILayer layer,
            IReference<AnalysisProfile> analysis_profile)
        {
            if (layer == null)
                throw new NotSupportedException("The layer reference that determines " +
                    "the default target currency is null.");
            if (layer is AggregateQuotaShare aggregateQuotaShare)
                return aggregateQuotaShare.aggregate_limit.currency;
            if (layer is AggXL aggXL)
                return aggXL.aggregate_limit.currency;
            if (layer is CatXL catXL)
                return catXL.limit.currency;
            if (layer is QuotaShare quotaShare)
                return quotaShare.event_limit.currency;
            if (layer is SurplusShare surplusShare)
                return surplusShare.retained_line.currency;
            if (layer is IndustryLossWarranty industryLossWarranty)
                return industryLossWarranty.payout.currency;
            if (layer is Nested nested)
            {
                IAPIResource sinkValue = nested.sink.GetValue();
                return sinkValue is ILayer asLayer ? GetDefaultFromLayer(asLayer, analysis_profile) :
                    GetDefaultTargetCurrency(sinkValue);
            }
            if (layer is ValueAllocator valueAllocator)
            {
                IAPIResource sourceValue = valueAllocator.source.GetValue();
                return sourceValue is ILayer asLayer ? GetDefaultFromLayer(asLayer, analysis_profile) :
                    GetDefaultTargetCurrency(sourceValue);
            }
            if (layer is BackAllocatedLayer backAllocatedLayer)
            {
                IAPIResource sinkValue = backAllocatedLayer.sink.GetValue();
                return sinkValue is ILayer asLayer ? GetDefaultFromLayer(asLayer, analysis_profile) :
                    GetDefaultTargetCurrency(sinkValue);
            }
            if (layer is Filter || layer is LossRank || layer is DelayedPayment || layer is FixedDatePayment)
                return analysis_profile.GetValue().exchange_rate_profile.GetValue()
                    .exchange_rate_table.GetValue().base_currency;
            if (layer is FixedRateCurrencyConverter fixedRateCurrency)
                return fixedRateCurrency.out_currency;
            if (layer is NoClaimsBonus noClaimsBonus)
                return noClaimsBonus.payout_amount.currency;
            throw new NotSupportedException("Unexpected layer type: " + layer.GetType() +
                ". Could not determine the default target currency.");
        }
    }
}