from django.db import models

from .base import Currency, Term, Unit
from .providers import CloudProvider
from .services import Service


class ComputePlanGroup(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField(blank=True)
    node_label = models.CharField(
        max_length=100, help_text="Kubernetes node label for this group"
    )
    order = models.IntegerField(default=0)

    class Meta:
        ordering = ["order", "name"]

    def __str__(self):
        return self.name


class ComputePlanPrice(models.Model):
    compute_plan = models.ForeignKey(
        "ComputePlan", on_delete=models.CASCADE, related_name="prices"
    )
    currency = models.CharField(
        max_length=3,
        choices=Currency.choices,
    )
    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        help_text="Price in the specified currency, excl. VAT",
    )

    class Meta:
        unique_together = ("compute_plan", "currency")
        ordering = ["currency"]

    def __str__(self):
        return f"{self.compute_plan.name} - {self.amount} {self.currency}"


class ComputePlan(models.Model):
    name = models.CharField(max_length=200)
    vcpus = models.FloatField(help_text="Number of available vCPUs")
    ram = models.FloatField(help_text="Amount of RAM available")
    cpu_mem_ratio = models.FloatField(
        help_text="vCPU to Memory ratio. How much vCPU per GiB RAM is available?"
    )
    active = models.BooleanField(default=True, help_text="Is the plan active?")
    term = models.CharField(
        max_length=3,
        default=Term.MTH,
        choices=Term.choices,
    )

    cloud_provider = models.ForeignKey(
        CloudProvider, on_delete=models.CASCADE, related_name="compute_plans"
    )

    group = models.ForeignKey(
        ComputePlanGroup,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name="compute_plans",
        help_text="Group this compute plan belongs to",
    )

    valid_from = models.DateTimeField(blank=True, null=True)
    valid_to = models.DateTimeField(blank=True, null=True)

    class Meta:
        ordering = ["name"]

    def __str__(self):
        return self.name

    def get_price(self, currency_code: str):
        try:
            return self.prices.get(currency=currency_code).amount
        except ComputePlanPrice.DoesNotExist:
            return None


class StoragePlanPrice(models.Model):
    storage_plan = models.ForeignKey(
        "StoragePlan", on_delete=models.CASCADE, related_name="prices"
    )
    currency = models.CharField(
        max_length=3,
        choices=Currency.choices,
    )
    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        help_text="Price in the specified currency, excl. VAT",
    )

    class Meta:
        unique_together = ("storage_plan", "currency")
        ordering = ["currency"]

    def __str__(self):
        return f"{self.storage_plan.name} - {self.amount} {self.currency}"


class StoragePlan(models.Model):
    name = models.CharField(max_length=200)
    cloud_provider = models.ForeignKey(
        CloudProvider, on_delete=models.CASCADE, related_name="storage_plans"
    )
    term = models.CharField(
        max_length=3,
        default=Term.MTH,
        choices=Term.choices,
    )
    unit = models.CharField(
        max_length=3,
        default=Unit.GIB,
        choices=Unit.choices,
    )

    valid_from = models.DateTimeField(blank=True, null=True)
    valid_to = models.DateTimeField(blank=True, null=True)

    class Meta:
        unique_together = ("cloud_provider", "term", "unit", "valid_from", "valid_to")
        ordering = ["name"]

    def __str__(self):
        return self.name

    def get_price(self, currency_code: str):
        try:
            return self.prices.get(currency=currency_code).amount
        except StoragePlanPrice.DoesNotExist:
            return None


class ProgressiveDiscountModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    active = models.BooleanField(default=True)

    class Meta:
        verbose_name = "Discount Model"

    def __str__(self):
        return self.name

    def calculate_discount(self, base_rate, units):
        """Calculate price using progressive percentage discounts."""
        final_price = 0
        remaining_units = units

        discount_tiers = self.tiers.all().order_by("min_units")

        for tier in discount_tiers:
            if remaining_units <= 0:
                break

            # Determine how many units fall into this tier
            tier_min = tier.min_units
            tier_max = tier.max_units if tier.max_units else float("inf")

            # Skip if we haven't reached this tier yet
            if units < tier_min:
                continue

            # Calculate units in this tier
            units_start = max(0, units - remaining_units)
            units_end = min(units, tier_max if tier.max_units else units)
            tier_units = max(0, units_end - max(units_start, tier_min - 1))

            if tier_units > 0:
                discounted_rate = base_rate * (1 - tier.discount_percent / 100)
                final_price += discounted_rate * tier_units
                remaining_units -= tier_units

        return final_price

    def get_discount_breakdown(self, base_rate, units):
        """Get detailed breakdown of discount calculation."""
        breakdown = []
        remaining_units = units

        discount_tiers = self.tiers.all().order_by("min_units")

        for tier in discount_tiers:
            if remaining_units <= 0:
                break

            tier_min = tier.min_units
            tier_max = tier.max_units if tier.max_units else float("inf")

            if units < tier_min:
                continue

            units_start = max(0, units - remaining_units)
            units_end = min(units, tier_max if tier.max_units else units)
            tier_units = max(0, units_end - max(units_start, tier_min - 1))

            if tier_units > 0:
                discounted_rate = base_rate * (1 - tier.discount_percent / 100)
                tier_total = discounted_rate * tier_units

                breakdown.append(
                    {
                        "tier_range": f"{tier_min}-{tier_max-1 if tier.max_units else '∞'}",
                        "units": tier_units,
                        "discount_percent": tier.discount_percent,
                        "rate": discounted_rate,
                        "subtotal": tier_total,
                    }
                )

                remaining_units -= tier_units

        return breakdown


class DiscountTier(models.Model):
    discount_model = models.ForeignKey(
        ProgressiveDiscountModel, on_delete=models.CASCADE, related_name="tiers"
    )
    min_units = models.PositiveIntegerField(
        help_text="Minimum unit count for this tier (inclusive)", default=0
    )
    max_units = models.PositiveIntegerField(
        null=True,
        blank=True,
        help_text="Maximum unit count for this tier (exclusive). Leave blank for unlimited.",
    )
    discount_percent = models.DecimalField(
        max_digits=5, decimal_places=2, help_text="Percentage discount applied (0-100)"
    )

    class Meta:
        ordering = ["min_units"]
        unique_together = ["discount_model", "min_units"]

    def __str__(self):
        if self.max_units:
            return f"{self.discount_model.name}: {self.min_units}-{self.max_units-1} units → {self.discount_percent}% discount"
        else:
            return f"{self.discount_model.name}: {self.min_units}+ units → {self.discount_percent}% discount"


class VSHNAppCatBaseFee(models.Model):
    vshn_appcat_price_config = models.ForeignKey(
        "VSHNAppCatPrice", on_delete=models.CASCADE, related_name="base_fees"
    )
    currency = models.CharField(
        max_length=3,
        choices=Currency.choices,
    )
    amount = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        help_text="Base fee in the specified currency, excl. VAT",
    )

    class Meta:
        verbose_name = "Service Base Fee"
        unique_together = ("vshn_appcat_price_config", "currency")
        ordering = ["currency"]

    def __str__(self):
        return f"{self.vshn_appcat_price_config.service.name} Base Fee - {self.amount} {self.currency}"


class VSHNAppCatPrice(models.Model):
    class VariableUnit(models.TextChoices):
        RAM = "RAM", "Memory (RAM)"
        CPU = "CPU", "CPU (vCPU)"
        USER = "USR", "Users"

    class ServiceLevel(models.TextChoices):
        BEST_EFFORT = "BE", "Best Effort"
        GUARANTEED = "GA", "Guaranteed Availability"

    service = models.ForeignKey(
        Service, on_delete=models.CASCADE, related_name="vshn_appcat_price"
    )
    variable_unit = models.CharField(
        max_length=3,
        choices=VariableUnit.choices,
        default=VariableUnit.RAM,
    )
    term = models.CharField(
        max_length=3,
        default=Term.MTH,
        choices=Term.choices,
    )
    discount_model = models.ForeignKey(
        ProgressiveDiscountModel,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name="price_configs",
    )

    ha_replica_min = models.IntegerField(
        default=1, help_text="Minimum of replicas for HA"
    )
    ha_replica_max = models.IntegerField(
        default=1, help_text="Maximum supported replicas"
    )

    valid_from = models.DateTimeField(blank=True, null=True)
    valid_to = models.DateTimeField(blank=True, null=True)

    class Meta:
        verbose_name = "AppCat Price"

    def __str__(self):
        return f"{self.service.name} - {self.get_variable_unit_display()} based pricing"

    def get_base_fee(self, currency_code: str):
        try:
            return self.base_fees.get(currency=currency_code).amount
        except VSHNAppCatBaseFee.DoesNotExist:
            return None

    def get_unit_rate(self, currency_code: str, service_level: str):
        try:
            return self.unit_rates.get(
                currency=currency_code, service_level=service_level
            ).amount
        except VSHNAppCatUnitRate.DoesNotExist:
            return None

    def calculate_final_price(
        self, currency_code: str, service_level: str, number_of_units: int
    ):
        base_fee = self.get_base_fee(currency_code)
        unit_rate = self.get_unit_rate(currency_code, service_level)

        if base_fee is None or unit_rate is None:
            return None

        if number_of_units < 0:
            raise ValueError("Number of units cannot be negative")

        # Apply discount model if available
        if self.discount_model and self.discount_model.active:
            discounted_price = self.discount_model.calculate_discount(
                unit_rate, number_of_units
            )
            total_price = base_fee + discounted_price
        else:
            total_price = base_fee + (unit_rate * number_of_units)

        return total_price


class VSHNAppCatUnitRate(models.Model):
    vshn_appcat_price_config = models.ForeignKey(
        VSHNAppCatPrice, on_delete=models.CASCADE, related_name="unit_rates"
    )
    currency = models.CharField(
        max_length=3,
        choices=Currency.choices,
    )
    service_level = models.CharField(
        max_length=2,
        choices=VSHNAppCatPrice.ServiceLevel.choices,
    )
    amount = models.DecimalField(
        max_digits=10,
        decimal_places=4,
        help_text="Price per unit in the specified currency and service level, excl. VAT",
    )

    class Meta:
        verbose_name = "Service Unit Rate"
        unique_together = ("vshn_appcat_price_config", "currency", "service_level")
        ordering = ["currency", "service_level"]

    def __str__(self):
        return f"{self.vshn_appcat_price_config.service.name} - {self.get_service_level_display()} Unit Rate - {self.amount} {self.currency}"
