"""Factories for creating test data.

The intention is to replace the seed and fixture data since it's difficult
to come up with test data.
"""
from datetime import date
from datetime import datetime
from datetime import timedelta

import factory

from backend.constants import track_field
from backend.models.focus_track import FocusTrack
from backend.models.instant_grats import InstantGrat
from backend.models.language import Language
from backend.models.performer import Performer
from backend.models.track import Track
from backend.models.track import TrackArtist
from backend.models.track import TrackPublisher
from backend.models.track import TrackWriter
from tests.testutils.fixtures.performer_roles_fixture import performer_roles


def _generate_artists(track, create, extracted, artist_type, **kwargs):
    """Generate artist data for track."""
    if not create:
        return

    if extracted:
        for val in extracted:
            track.artists.append(
                TrackArtistFactory.build(
                    tuid=track.tuid, artist_type=artist_type, artist_name=val))

    count = kwargs.get('count', 0)
    for x in range(0, count):
        track.artists.append(
            TrackArtistFactory.build(tuid=track.tuid, artist_type=artist_type))


class TrackFactory(factory.Factory):
    """Factory to create ItunesLanguages model instance for testing.

    Call TrackFactory.create to use. You can specify the field name to
    set a specific value (i.e. explicit='Y').

    There are special variables to seed related data for artists and writers.
    Artists can specified by passing in <artist_role>__count, while writers
    can be specified by writers_count. For example to create a track with 2
    performers, a remixer, and a writer:

        track = TrackFactory.create(
            performer__count=2, remixer__count=1, writers__count=1)
    """

    tuid = factory.Sequence(lambda n: n + 1)
    product_id = 1

    track_name = factory.Sequence(lambda n: 'Track {}'.format(n + 1))
    version = ''
    explicit = 'N'
    upc = 123456789012
    isrc = factory.LazyAttribute(lambda o: 'us-123-17-{:05d}'.format(o.tuid))
    p_info = '2017 Label'
    meta_language_code = 'ENG'
    ownership_rights = 'no_rights'
    preview_start_time = None
    track_type = track_field.TRACK_TYPE_MUSIC
    offer_type = track_field.OFFER_TYPE_ALL

    track_number = factory.Sequence(lambda n: n + 1)
    volume_number = 1

    third_party_publisher = 'N'

    class Meta:  # noqa: D106
        model = Track

    @factory.post_generation
    def performer(self, create, extracted, **kwargs):
        """Generate performers."""
        _generate_artists(self, create, extracted, 'performer', **kwargs)

    @factory.post_generation
    def featuring(self, create, extracted, **kwargs):
        """Generate featuring artists."""
        _generate_artists(self, create, extracted, 'featuring', **kwargs)

    @factory.post_generation
    def remixer(self, create, extracted, **kwargs):
        """Generate remixers."""
        _generate_artists(self, create, extracted, 'remixer', **kwargs)

    @factory.post_generation
    def composer(self, create, extracted, **kwargs):
        """Generate composers."""
        _generate_artists(self, create, extracted, 'composer', **kwargs)
        
    @factory.post_generation
    def orchestra(self, create, extracted, **kwargs):
        """Generate orchestras."""
        _generate_artists(self, create, extracted, 'orchestra', **kwargs)
        
    @factory.post_generation
    def conductor(self, create, extracted, **kwargs):
        """Generate conductors."""
        _generate_artists(self, create, extracted, 'conductor', **kwargs)

    @factory.post_generation
    def soloist(self, create, extracted, **kwargs):
        """Generate legacy artist_type soloists."""
        _generate_artists(self, create, extracted, 'soloist', **kwargs)

    @factory.post_generation
    def producer(self, create, extracted, **kwargs):
        """Generate producers."""
        _generate_artists(self, create, extracted, 'producer', **kwargs)

    @factory.post_generation
    def writers(self, create, extracted, **kwargs):
        """Generate writers."""
        if not create:
            return

        if extracted:
            for val in extracted:
                self.writers.append(
                    TrackWriterFactory.build(
                        tuid=self.tuid, writer_name=val, upc=self.upc,
                        volume_number=self.volume_number,
                        track_number=self.track_number))
        else:
            count = kwargs.get('count', 0)
            for x in range(0, count):
                self.writers.append(TrackWriterFactory.build(
                    tuid=self.tuid, upc=self.upc,
                    volume_number=self.volume_number,
                    track_number=self.track_number))

    @factory.post_generation
    def publishers(self, create, extracted, **kwargs):
        """Generate publishers."""
        if not create:
            return

        if extracted:
            for val in extracted:
                self.publishers.append(
                    TrackPublisherFactory.build(
                        tuid=self.tuid, publisher_name=val, upc=self.upc))
        else:
            count = kwargs.get('count', 0)
            for x in range(0, count):
                self.publishers.append(
                    TrackPublisherFactory.build(tuid=self.tuid, upc=self.upc))

    @factory.post_generation
    def language(self, create, extracted, **kwargs):
        """Generate language."""
        if not create:
            return
        else:
            self.language = LanguageFactory.build(language_code='ENG')

    @factory.post_generation
    def focus_track(self, create, extracted, **kwargs):
        """Generate focus track."""
        if not create:
            return

        if extracted:
            start_date = kwargs.get('start_date', None)
            end_date = kwargs.get('end_date', None)
            if start_date and end_date:
                self._focus_track = FocusTrackFactory.build(
                    tuid=self.tuid, start_date=start_date, end_date=end_date)
            else:
                self._focus_track = FocusTrackFactory.build(tuid=self.tuid, **kwargs)


class TrackArtistFactory(factory.Factory):
    """Factory to create TrackArtist model instance for testing."""

    track_artist_id = factory.Sequence(lambda n: n + 1)

    artist_type = 'performer'
    artist_name = factory.Faker('name')

    class Meta:  # noqa: D106
        model = TrackArtist


class TrackWriterFactory(factory.Factory):
    """Factory to create TrackWriter model instance for testing."""

    track_writer_id = factory.Sequence(lambda n: n + 1)
    writer_name = factory.Faker('name')

    class Meta:  # noqa: D106
        model = TrackWriter


class TrackPublisherFactory(factory.Factory):
    """Factory to create TrackPublisher model instance for testing."""

    track_publisher_id = factory.Sequence(lambda n: n + 1)
    publisher_name = factory.Faker('name')

    class Meta:  # noqa: D106
        model = TrackPublisher


class TrackLocalizationFactory():
    """Track Localization Factory."""

    def __new__(cls, track, language_ids):
        """Create track localizations."""
        track_dict = track
        if isinstance(track, Track):
            track_dict = track.to_dict()

        return [
            cls.localize_track(track_dict, language_id)
            for language_id in language_ids]

    @classmethod
    def localize_track(cls, track_dict, language_id):
        """Localize track with language_id."""
        localization = {
            track_field.TUID: track_dict[track_field.TUID],
            track_field.LANGUAGE_ID: language_id}

        localization[track_field.TRACK_NAME] = '{} lang {}'.format(
            track_dict[track_field.TRACK_NAME], language_id)

        version = track_dict[track_field.VERSION]
        if version:
            version = '{} lang {}'.format(version, language_id)
        localization[track_field.VERSION] = version

        artists = []
        for artist in track_dict[track_field.ARTISTS]:
            localized_artist = artist.copy()
            localized_artist[track_field.NAME] = '{} lang {}'.format(
                artist[track_field.NAME], language_id)
            artists.append(localized_artist)

        localization[track_field.ARTISTS] = artists

        return localization


class PerformerFactory(factory.Factory):
    """Factory to create Performer model instance for testing."""

    performer_id = factory.Sequence(lambda n: n + 1)

    performer_role_id = factory.LazyAttribute(
        lambda o: o.tuid % len(performer_roles))

    birth_name = factory.Faker('name')

    class Meta:  # noqa: D106
        model = Performer


class InstantGratFactory(factory.Factory):
    """Factory to create InstantGrat model instance for testing."""

    instant_grat_id = factory.Sequence(lambda n: n + 1)
    store_id = 1
    active = 'Y'
    date = datetime(year=2017, month=5, day=20)
    user_id = factory.Faker('user_id')
    user_type = factory.Faker('user_type')
    date_created = factory.LazyFunction(datetime.now)

    class Meta:  # noqa: D106
        model = InstantGrat


class LanguageFactory(factory.Factory):
    """Factory to create Language model instance for testing."""

    language_code = 'ENG'
    language = 'English'
    iso_639_1_code = 'EN'
    iso_code_639_3_code = None
    apple_compatible = True

    class Meta:  # noqa: D106
        model = Language


class FocusTrackFactory(factory.Factory):
    """Factory to create Focus Track model instance for testing."""

    product_id = 1

    start_date = factory.Faker(
        'date_between_dates',
        date_start=date.today() - timedelta(days=20),
        date_end=date.today(),
    )
    end_date = factory.Faker(
        'date_between_dates',
        date_start=date.today() + timedelta(days=1),
        date_end=date.today() + timedelta(days=20),
    )

    class Meta:  # noqa: D106
        model = FocusTrack