"""ows-video factory."""

import random
import uuid
from datetime import datetime, timezone

from factory import Factory, lazy_attribute
from factory.fuzzy import FuzzyChoice, FuzzyInteger

from spec.jsonschema.job_inputs import JOB_TYPE_TO_CREATE_JOB_INPUTS_SCHEMA_MAP
from spec.jsonschema.job_outputs import JOB_TYPE_TO_CREATE_JOB_OUTPUTS_SCHEMA_MAP
from video import config
from video.constants import job_statuses, job_types
from video.models.ows.classes.video import (
    VideoJob,
    VideoJobAddInputs,
    VideoJobAddOutputs,
    VideoJobChangeStatus,
    VideoJobContext,
    VideoJobCreate,
)

from tests.testutils.jsonschema import get_fake_data
from tests.unit.factories.custom_fuzzy_fields import FuzzyOrchardUserId


class VideoJobContextFactory(Factory[VideoJobContext]):
    """VideoJobContextFactory Class."""

    class Meta:
        """VideoJobContextFactory Meta Class."""

        model = VideoJobContext

    context_id = FuzzyInteger(1, 999999)
    vendor_id = FuzzyInteger(1, 999999)
    subaccount_id = FuzzyInteger(1, 999999)
    user_id = FuzzyOrchardUserId()
    product_id = FuzzyInteger(1, 999999)
    correlation_id = lazy_attribute(lambda o: str(uuid.uuid1()))
    datetime = lazy_attribute(
        lambda o: datetime.now(timezone.utc).strftime(config.RFC3339_DATETIME_FORMAT)
    )


class VideoJobFactory(Factory[VideoJob]):
    """VideoJobFactory Class."""

    class Meta:
        """VideoJobFactory Meta Class."""

        model = VideoJob

    job_id = FuzzyInteger(1, 999999)
    job_type: str = FuzzyChoice(job_types.JOB_TYPES)  # type: ignore[assignment]
    job_status: str = FuzzyChoice(job_statuses.JOB_STATUSES)  # type: ignore[assignment]
    job_parent_id = FuzzyInteger(1, 999999)
    context = lazy_attribute(lambda o: VideoJobContextFactory())

    inputs = lazy_attribute(
        lambda o: get_fake_data(JOB_TYPE_TO_CREATE_JOB_INPUTS_SCHEMA_MAP[o.job_type])
    )
    outputs = lazy_attribute(
        lambda o: (
            None
            if o.job_status == job_statuses.SETUP
            else (get_fake_data(JOB_TYPE_TO_CREATE_JOB_OUTPUTS_SCHEMA_MAP[o.job_type]))
        )
    )


class VideoJobCreateFactory(Factory[VideoJobCreate]):
    """VideoJobCreateFactory Class."""

    class Meta:
        """VideoJobCreateFactory Meta Class."""

        model = VideoJobCreate

    job_type: str = FuzzyChoice(job_types.JOB_TYPES)  # type: ignore[assignment]
    job_status: str = FuzzyChoice(  # type: ignore[assignment]
        [job_statuses.SETUP, job_statuses.SUBMITTED]
    )
    job_parent_id = FuzzyInteger(1, 999999)
    context = lazy_attribute(lambda o: {"product_id": random.randint(1, 999999)})
    inputs = lazy_attribute(
        lambda o: get_fake_data(JOB_TYPE_TO_CREATE_JOB_INPUTS_SCHEMA_MAP[o.job_type])
    )


class VideoJobChangeStatusFactory(Factory[VideoJobChangeStatus]):
    """VideoJobChangeStatusFactory Class."""

    class Meta:
        """VideoJobChangeStatusFactory Meta Class."""

        model = VideoJobChangeStatus

    job_id = FuzzyInteger(1, 999999)
    job_status: str = FuzzyChoice(job_statuses.JOB_STATUSES)  # type: ignore[assignment]


class VideoJobAddInputsFactory(Factory[VideoJobAddInputs]):
    """VideoJobAddInputsFactory Class."""

    class Meta:
        """VideoJobAddInputsFactory Meta Class."""

        model = VideoJobAddInputs

    job_id = FuzzyInteger(1, 999999)
    job_type: str = FuzzyChoice(job_types.JOB_TYPES)  # type: ignore[assignment]
    inputs = lazy_attribute(
        lambda o: get_fake_data(JOB_TYPE_TO_CREATE_JOB_INPUTS_SCHEMA_MAP[o.job_type])
    )


class VideoJobAddOutputsFactory(Factory[VideoJobAddOutputs]):
    """VideoJobAddOutputsFactory Class."""

    class Meta:
        """VideoJobAddOutputsFactory Meta Class."""

        model = VideoJobAddOutputs

    job_id = FuzzyInteger(1, 999999)
    job_type: str = FuzzyChoice(job_types.JOB_TYPES)  # type: ignore[assignment]
    outputs = lazy_attribute(
        lambda o: get_fake_data(JOB_TYPE_TO_CREATE_JOB_OUTPUTS_SCHEMA_MAP[o.job_type])
    )