"""Track data generator."""

from backend.constants import track_field as tf


class TrackGenerator(object):
    """Generates track seed data."""

    @property
    def tuid(self):
        """Get tuid."""
        return self._tuid

    @property
    def product_id(self):
        """Get product_id."""
        return self._product_id

    @property
    def items(self):
        """Get items."""
        return self._items.copy()

    def __init__(self):
        """Constructor."""
        self._tuid = 0
        self._product_id = 0
        self._items = []

    def add_products(self, data_list):
        """Add tracks for products.

        Args:
            data_list (list): List of dicts with products to add.
        """
        for data in data_list:
            self.add_product(**data)

    def add_product(
            self, product_id, upc, track_name, volumes,
            isrc, p_info, explicit, recording_country_id=None,
            meta_language_code=None):
        """Add track for product with specified volumes.

        Args:
            track_name (string): track name, can use {product_id}, {volume},
                           and {track_number} as placeholders
            upc (int): UPC for product
            volumes (tuple): has number of tracks (int) for each volume
            recording_country_id (int): Recording country id
            meta_language_code (str): Metadata language
        """
        self._product_id += 1
        volume_num = 1
        for num_tracks in volumes:
            self._add_tracks(
                self._product_id, track_name, upc, volume_num, num_tracks,
                isrc, p_info, explicit, recording_country_id,
                meta_language_code)
            volume_num += 1

    def _add_tracks(
            self, product_id, track_name, upc, volume_number, num_tracks,
            isrc, p_info, explicit, recording_country_id, meta_language_code):
        """Add a set of tracks for a given product and volume.

        Args:
            product_id (int): product_id to add
            track_name (string): track name, can use {product_id}, {volume},
                           and {track_number} as placeholders
            volume_number (int): volume number of tracks
            num_tracks (int): number of tracks to create
            meta_language_code (str): Metadata language
        """
        for track_number in range(1, num_tracks + 1):
            track = self._generate_seed_dict(
                product_id,
                track_name,
                upc,
                volume_number,
                num_tracks + 1 - track_number,
                isrc,
                p_info,
                explicit,
                recording_country_id,
                meta_language_code
            )

            self._items.append(track)

    def _increment_tuid(self):
        """Increment and return tuid."""
        self._tuid += 1

    def _generate_seed_dict(
            self, product_id, track_name, upc, volume_number, track_number,
            isrc, p_info, explicit, recording_country_id, meta_language_code):
        """Build track dict item."""
        self._increment_tuid()
        formatted_name = track_name.format(
            product_id=product_id, volume_number=volume_number,
            track_number=track_number)

        return {
            tf.TUID: self.tuid,
            tf.PRODUCT_ID: product_id,
            tf.UPC: upc,
            tf.TRACK_NAME: formatted_name,
            tf.VERSION: None,
            tf.META_LANGUAGE_CODE: meta_language_code,
            tf.P_INFO: p_info,
            tf.VOLUME_NUMBER: volume_number,
            tf.TRACK_NUMBER: track_number,
            tf.RECORDING_COUNTRY_ID: recording_country_id,
            tf.ISRC: isrc,
            tf.EXPLICIT: explicit
        }