import argparse
import json
import fp
import time


def match_for_json(fp_json_file, output_file):

    csv_file = open(output_file, 'w')
    csv_file.write(
        'track_id,artist,track,release_name,master_id,score,first_master,duration\n'
    )
    fp.erase_database(really_delete=True)
    master_counter = 0
    master_dict = {}

    codes = json.load(open(fp_json_file))
    for code in codes:
        if 'error' not in code:
            fingerprint = code['code']
            match_data = fp.best_match_for_query(fingerprint)

            track_id = get_track_id_from_filename(code['metadata']['filename'])

            track_id_str = str(track_id)
            artist_str = str(code['metadata']['artist'])
            track_str = str(code['metadata']['title'])
            release_str = str(code['metadata']['release'])
            duration_str = str(code['metadata']['duration'])
            code_count = code['code_count']
            if float(code_count) == 0.0:
                score = int(0)
            else:
                score = int(float(match_data.score) / float(code_count) * 100)

            if (match_data.code not in [3, 5, 6, 8]):
                # no matches, make this the master
                master_counter += 1
                # set fingerprint in dict
                master_dict[track_id] = master_counter

                csv_file.write(
                    ",".join([track_id_str, artist_str, track_str,
                              release_str, str(master_counter),
                              'NULL', '1', duration_str+'\n'])
                )
                data = format_for_ingestion(code)
                fp.ingest(data, do_commit=True, split=False)
            else:
                # append data for strongest match, don't ingest
                score_str = str(score)
                matched_track_id = get_track_id_from_filename(match_data.TRID)
                csv_file.write(
                    ",".join([track_id_str, artist_str, track_str,
                              release_str, str(master_dict[matched_track_id]),
                              score_str, '0', duration_str+'\n'])
                )

    csv_file.close()


def get_track_id_from_filename(filename):
    cut_start = filename.rsplit('/', 1)[-1]
    cut_end = cut_start.split('.', 1)[0]
    cut_dash = cut_end.split('-', 1)[0]
    return cut_dash


def format_for_ingestion(c):
    # taken from util/fastingest.py
    if "code" not in c:
        return
    code = c["code"]
    m = c["metadata"]
    if "filename" in m:
        track_id = get_track_id_from_filename(m["filename"])
        trid = track_id.encode("utf-8")
    else:
        trid = fp.new_track_id()
    length = m["duration"]
    version = m["version"]
    artist = m.get("artist", None)
    title = m.get("title", None)
    release = m.get("release", None)
    decoded = fp.decode_code_string(code)

    data = {"track_id": trid,
            "fp": decoded,
            "length": length,
            "codever": "%.2f" % version
            }
    if artist:
        data["artist"] = artist
    if release:
        data["release"] = release
    if title:
        data["track"] = title
    return data


def get_cl_args():
    """Process command-line args
    Args:
        Argparse Namespace object containing args and/or defaults
    """
    help_str = """
    Ingest and query for fingerprint matches given a fingerprints json file
    python bulk_match.py allcodes.json output.csv
    """
    parser = argparse.ArgumentParser(help_str)
    parser.add_argument('fp_json_file',
                        type=str,
                        help='path to fingerprint json file')
    parser.add_argument('output_file',
                        type=str,
                        help='path to output file')
    return parser.parse_args()


def main():
    start = time.time()
    args = get_cl_args()
    print("args: {}".format(args))
    match_for_json(args.fp_json_file, args.output_file)
    elapsed_time = time.time() - start
    print('elapsed time: {} seconds'.format(round(elapsed_time, 3)))


if __name__ == "__main__":
    main()