from decimal import Decimal

from template_project.application.common.data_structure import to_data_structure
from template_project.application.common.enums import ExperienceType
from template_project.application.common.identity_provider import IdentityProvider
from template_project.application.common.interactor import to_interactor
from template_project.application.resume.data_gateway import ResumeDataGateway, ResumePredictionDataGateway
from template_project.application.resume.entity import ResumeId
from template_project.application.resume.errors import ResumeDoesBelongUserError


@to_data_structure
class ResumePredictionResponse:
    from_salary: Decimal
    to_salary: Decimal
    recommended_skills: list[str]


@to_data_structure
class _Response:
    id: ResumeId
    position: str
    about_me: str
    key_skills: list[str]
    experience_type: ExperienceType
    prediction: ResumePredictionResponse | None


@to_interactor
class GetResumeInteractor:
    identity_provider: IdentityProvider
    resume_data_gateway: ResumeDataGateway
    resume_prediction_data_gateway: ResumePredictionDataGateway

    async def execute(
        self,
        resume_id: ResumeId,
    ) -> _Response:
        user = await self.identity_provider.get_current_user()

        resume = await self.resume_data_gateway.load(resume_id)

        if resume.user_id != user.id:
            raise ResumeDoesBelongUserError

        resume_prediction = await self.resume_prediction_data_gateway.load_by_resume_id(resume.id)
        if resume_prediction is not None:
            prediction = ResumePredictionResponse(
                from_salary=resume_prediction.from_salary,
                to_salary=resume_prediction.to_salary,
                recommended_skills=resume_prediction.recommended_skills,
            )
        else:
            prediction = None

        return _Response(
            id=resume.id,
            position=resume.position,
            about_me=resume.about_me,
            key_skills=resume.key_skills,
            experience_type=resume.experience_type,
            prediction=prediction,
        )


@to_data_structure
class ResumeListItemResponse:
    position: str
    about_me: str
    key_skills: list[str]
    experience_type: ExperienceType


@to_interactor
class GetResumeListInteractor:
    identity_provider: IdentityProvider
    resume_data_gateway: ResumeDataGateway

    async def execute(self, limit: int, offset: int) -> list[ResumeListItemResponse]:
        user = await self.identity_provider.get_current_user()

        resumes = await self.resume_data_gateway.list_by_user_id(user.id, limit=limit, offset=offset)

        return [
            ResumeListItemResponse(
                position=r.position,
                about_me=r.about_me,
                key_skills=r.key_skills,
                experience_type=r.experience_type,
            )
            for r in resumes
        ]