import datetime
from typing import List, Tuple

from token_bot.history_manager.update_trigger import UpdateTrigger
from token_bot.persistant_database import AlertType, Alert
from token_bot.token_database.flavor import Flavor
from token_bot.token_database.region import Region


class History:
    def __init__(self, flavor: Flavor, region: Region):
        self._flavor: Flavor = flavor
        self._region: Region = region
        self._history: List[Tuple[datetime, int]] = []
        self._last_price_movement: int = 0
        self._latest_price_datum: Tuple[datetime.datetime, int] | None = None
        self._update_triggers: List[UpdateTrigger] = []
        # Create triggers for all non-custom alert types
        for alert_type in AlertType:
            if alert_type != AlertType.SPECIFIC_PRICE:
                self._update_triggers.append(
                    UpdateTrigger(Alert(alert_type, flavor, self._region))
                )
        # SPECIFIC_PRICE triggers are created on-demand as they have unique prices

    @property
    def flavor(self) -> Flavor:
        return self._flavor

    @property
    def region(self) -> Region:
        return self._region

    @property
    def last_price_datum(self) -> Tuple[datetime.datetime, int] | None:
        return self._latest_price_datum

    @property
    def last_price_movement(self) -> int:
        return self._last_price_movement

    @property
    def history(self) -> List[Tuple[datetime.datetime, int]]:
        return self._history

    async def _process_update_triggers(self) -> List[Alert]:
        alerts = []
        for trigger in self._update_triggers:
            if trigger.check_and_update(self._latest_price_datum, self._history):
                alerts.append(trigger.alert)
        return alerts

    async def add_price(self, datum: Tuple[datetime.datetime, int]) -> List[Alert]:
        if self._latest_price_datum is None:
            self._latest_price_datum = datum
        self._last_price_movement = datum[1] - self._latest_price_datum[1]
        self._latest_price_datum = datum
        self._history.append(datum)
        return await self._process_update_triggers()

    async def find_update_trigger_from_alert(self, alert: Alert, initial_import: bool = False) -> UpdateTrigger:
        for trigger in self._update_triggers:
            if trigger.alert == alert:
                return trigger

        # If not found and it's a SPECIFIC_PRICE alert, create it on-demand
        if alert.alert_type == AlertType.SPECIFIC_PRICE:
            new_trigger = UpdateTrigger(alert)
            if initial_import:
                new_trigger.squelched = True
            self._update_triggers.append(new_trigger)
            # Initialize the trigger with current history
            if self._latest_price_datum is not None:
                new_trigger.check_and_update(self._latest_price_datum, self._history)
            new_trigger.squelched = False
            return new_trigger

        raise ValueError