"""CS 149 Project 3, Part B: Nested Data.

Author: YOUR NAME
Version: THE DATE
"""


def process_args():  # pragma: no cover
    """Check the number and validity of the command-line arguments.

    There must be 2 arguments: the tags filename and the tracks filename.
    Print the required error message and exit if the number of arguments is
    incorrect or if either filename does not exist.

    Returns:
        tuple: (tagsfilename, tracksfilename)
    """
    return "", ""


def load_json(filename):  # pragma: no cover
    """Load the given JSON file and return the data.

    Arguments:
        filename (str): the filename of the JSON file to load

    Returns:
        list: the data from the JSON file assuming the top level is a list
    """
    return []


def clean_tags(tags, exclude, limit=None):
    """Return tag names excluding any in the exclude list or whose count is below the limit.

    Arguments:
        tags (list): A list of tag dictionaries
        exclude (list): A list of tag name strings to be excluded
        limit (int or None): OPTIONAL - exclude tags whose count is equal to or below the limit

    Returns:
        list: a list of lowercase strings that are acceptable tag names
    """
    return []


def format_tags(tags):
    """Format the list of tag names into 3 columns for display.

    Arguments:
        tags (list): a list of tag name strings

    Returns:
        str: a single string that will display the tags in 3 columns
    """
    return ""


def add_tag_to_set(name, tags, tagset):
    """Add the tag name to the tagset only if it appears in tags list, regardless of case.

    Also handle the special hip-hop issue.

    Arguments:
        name (str): the tag name to add to the set
        tags (list): a list of all tag names in lowercase
        tagset (set): add name to this set if it is a valid name
    """


def clean_durations(tracks, default_duration=300):
    """Clean the tracks' duration attribute: update its type & fix inconsistencies.

    Arguments:
        tracks (list): a list of track dictionaries
        default_duration (int): the value for missing durations; set to 300
                                seconds unless another value is provided.
    """


def tags_match(track, tagset):
    """Return True if any of a track's tag names are in the given tag set.

    Arguments:
        track (dict): a single track dictionary
        tagset (set): a set of tag names

    Returns:
        bool: True only if one of the track's tag names is in the tag set
    """
    return False


def create_playlist(tracks, tagset, minutes):
    """Create a playlist from the given tracks.

    This function searches the list of tracks and compiles a new list of tracks
    that match the tags and fit within the desired playlist length in minutes.

    Arguments:
        tracks (list): a list of track dictionaries
        tagset (set): a set of tag names
        minutes (int): the desired playlist length

    Returns:
        list: a list of track dictionaries for the songs in the playlist.
    """
    return []


def format_playlist(playlist):
    """Format a playlist as a string.

    Arguments:
        playlist (list): a list of track dictionaries

    Returns:
        str: a single string suitable for printing
    """
    return ""


def main():  # pragma: no cover
    """Given the 2 JSON data files on the command-line, have the user build a playlist."""
    # process the command line arguments
    tagfile, trackfile = process_args()

    # load the top 50 tags
    tags = load_json(tagfile)

    # remove the tags that are not really like genres,
    # optionally limit by popularity
    # get a new list of just tag names
    tags = clean_tags(tags, ["seen live", "chillout"])

    # format and show the tag names in 3 columns
    print("\nThese are the top tags, select as many as you want, enter 'stop' to end:\n")
    print(format_tags(tags))

    # let the user select a set of tags they are interested in
    ts = set()
    while (s := input("Enter a tag (or 'stop' to stop): ")) != 'stop':
        add_tag_to_set(s, tags, ts)
        # display the set as its being updated
        print(ts)

    # load the list of top tracks from the input file
    tracks = load_json(trackfile)

    # clean the duration attributes, optionally change the default duration
    clean_durations(tracks)

    # ask the user for a playlist length
    minutes = int(input("\nEnter your desired playlist length in minutes: "))
    # create the playlist
    playlist = create_playlist(tracks, ts, minutes)
    # display the playlist
    print("\nHere is your playlist created from the top 50 tracks on last.fm:")
    print(format_playlist(playlist))


if __name__ == "__main__":  # pragma: no cover
    main()