# !/usr/local/bin/python3

import csv
import argparse


def load_zip_data(filename='zips.csv'):
    """
        Loads zipcode data from a CSV file.
        :param filename: str - the name of the zipcode file. (zips.csv by default.)
        :return dict: Zipcode data, keyed on the zipcode.
    """
    zips = {}
    mras = []
    with open(filename, 'r') as zipfile:
        zipreader = csv.reader(zipfile, delimiter=",")
        next(zipreader, None)  # Skip headers
        for row in zipreader:
            if row[0] in mras:
                continue
            if row[0] in zips:
                dupe = zips.pop(row[0])
                if dupe['rate_area'] != row[4]:
                    mras.append(row[0])
                    continue
            zips[row[0]] = {
                'state': row[1],
                'rate_area': row[4]
            }
    return zips


def load_plan_data(filename='plans.csv'):
    """
        Loads plan data from a CSV file.
        :param filename: str - the name of the file with the plan data. (plans.csv by default.)
        :return dict: Plan data, keyed on State.
    """
    plans = {}
    with open(filename, 'r') as planfile:
        planreader = csv.reader(planfile, delimiter=",")
        next(planreader, None)  # Skip headers
        for row in planreader:
            state = row[1]
            metal_level = row[2]
            rate_area = row[4]
            rate = row[3]

            # We only care about Silver Plans
            if metal_level != 'Silver':
                continue

            if state in plans:
                state = plans[state]
                if rate_area in state:
                    state[rate_area].append(float(rate))
                else:
                    state[rate_area] = [float(rate)]
            else:
                plans[state] = {
                    rate_area: [float(rate)]
                }

    return plans


def process_data(*args, **kwargs):
    """
        Processes CSV file containing requested zipcodes, and outputs the data to a CSV file.
    """
    reasons = kwargs.pop('reasons', False)
    if 'zipfile' in kwargs:
        zips = load_zip_data(kwargs['zipfile'])
    else:
        zips = load_zip_data()

    if 'planfile' in kwargs:
        plans = load_plan_data(kwargs['planfile'])
    else:
        plans = load_plan_data()

    # Requested Zips
    if 'requestfile' in kwargs:
        requestfile = kwargs['requestfile']
    else:
        requestfile = 'slcsp.csv'

    output = [('zipcode', 'rate')]
    with open(requestfile, 'r') as requests:
        requestreader = csv.reader(requests, delimiter=',')
        next(requestreader)  # Skip headers
        for row in requestreader:
            try:
                zipcode = zips[row[0]]
            except KeyError:
                if reasons:
                    output.append((row[0], 'Zipcode was in multiple rate areas'))
                else:
                    output.append((row[0], ''))
                continue
            state = zipcode['state']
            rate_area = zipcode['rate_area']
            try:
                rates = sorted(plans[state][rate_area])
            except KeyError:
                if reasons:
                    output.append((row[0], f'{state} state not found'))
                else:
                    output.append((row[0], ''))
                continue
            if len(rates) > 1:
                output.append((row[0], rates[1]))
            else:
                if reasons:
                    output.append((row[0], f'Not enough plans!'))
                else:
                    output.append((row[0], ''))

    with open('output.csv', 'w', newline='') as outfile:
        outwriter = csv.writer(outfile, delimiter=',')
        outwriter.writerows(output)



if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--zipfile", help="Specify the name of the file containing all the zipcode data. (Must be CSV Format!)")
    parser.add_argument("--planfile", help="Specify the name of the file containing all the plan data. (Must be CSV Format!)")
    parser.add_argument("--requestfile", help="Specify the name of the file containing the zipcode requests. (Must be CSV Format!)")
    parser.add_argument("--reasons", type=bool, help="If set to true, output will include reasons for missing data.")

    args = parser.parse_args()

    kwargs = {}
    if args.zipfile:
        kwargs['zipfile'] = args.zipfile

    if args.planfile:
        kwargs['planfile'] = args.planfile

    if args.requestfile:
        kwargs['requestfile'] = args.requestfile

    if args.reasons:
        kwargs['reasons'] = args.reasons

    process_data(**kwargs)