import asyncpg
from typing import List, Dict
from ..services.cache_service import CacheService
from ..repositories.vehicles_repository import VehiclesRepository


class VehiclesService:
    def __init__(self, cache: CacheService, repo: VehiclesRepository | None = None):
        self.cache = cache
        self.repo = repo or VehiclesRepository()

    async def get_years(self, db: asyncpg.Connection) -> List[int]:
        cache_key = "dropdown:years"
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        years = await self.repo.get_years(db)
        await self.cache.set(cache_key, years, ttl=6 * 3600)
        return years

    async def get_makes(self, db: asyncpg.Connection, year: int) -> List[Dict]:
        cache_key = f"dropdown:makes:{year}"
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        makes = await self.repo.get_makes(db, year)
        await self.cache.set(cache_key, makes, ttl=6 * 3600)
        return makes

    async def get_models(self, db: asyncpg.Connection, year: int, make_id: int) -> List[Dict]:
        cache_key = f"dropdown:models:{year}:{make_id}"
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        models = await self.repo.get_models(db, year, make_id)
        await self.cache.set(cache_key, models, ttl=6 * 3600)
        return models

    async def get_trims(self, db: asyncpg.Connection, year: int, model_id: int) -> List[Dict]:
        cache_key = f"dropdown:trims:{year}:{model_id}"
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        trims = await self.repo.get_trims(db, year, model_id)
        await self.cache.set(cache_key, trims, ttl=6 * 3600)
        return trims

    async def get_engines(
        self, db: asyncpg.Connection, year: int, model_id: int, trim_id: int
    ) -> List[Dict]:
        cache_key = f"dropdown:engines:{year}:{model_id}:{trim_id}"
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        engines = await self.repo.get_engines(db, year, model_id, trim_id)
        await self.cache.set(cache_key, engines, ttl=6 * 3600)
        return engines