import argparse

import datetime

import query

import gmail

import config as conf

import mailConfig

import decimal

parser = argparse.ArgumentParser(description="""Generate report for the date specified.

                                 Start and end date default to present day.

                                 Start time defaults to 00:00:00.

                                 End time defaults to 23:59:59.""")

parser.add_argument('-s','--start-date', type=str, default=datetime.datetime.strftime(datetime.date.today(), '%Y-%m-%d'), help="Start date (YYYY-MM-DD)")

parser.add_argument('-e','--end-date', type=str, default=datetime.datetime.strftime(datetime.date.today(), '%Y-%m-%d'), help="End date (YYYY-MM-DD)")

parser.add_argument('-S','--start-time', type=str, default = '00:00:00', help="Start time (HH:MM:SS)")

parser.add_argument('-E','--end-time', type=str, default='23:59:59', help="End time (HH:MM:SS)")

parser.add_argument('-p','--print', type=bool, default=True, help="Print report on command line")

parser.add_argument('-m','--mail', type=bool, default=False, help="Mail report to addressess in mailConfig.py")

args = parser.parse_args()

startDate = args.start_date + " " + args.start_time

endDate = args.end_date + " " + args.end_time

postings = query.Query('lb_postings')

callDetails = query.Query('cdr')

average_call_length = callDetails.average(startDate, endDate)

audio_minutes = callDetails.sum(startDate, endDate)

mobilink_load = callDetails.call_distribution(startDate, endDate, 'mobilink')

mobilink_tata_load = callDetails.call_distribution(startDate, endDate, 'mobilinktata')

def individual_audio_minutes():

    """Return the total number of minutes on outgoing calls for every IP

    address of modems specified in conf.py

    """

    minutes = {}

    for ip in conf.ip_addr:

        minutes[ip] = callDetails.totalMinutes(ip, startDate, endDate)

    return minutes

def individual_load():

    """ Return the fraction of load on each modem."""

    minutes = individual_audio_minutes()

    for ip in minutes:

        minutes[ip] = round(minutes[ip]/audio_minutes, 4)

    return minutes

def genJSON():

    return ({"Number_of_postings_published": postings.posts(startDate,

                                                               endDate),

                "Number_of_recordings_made": postings.recordings(startDate,

                endDate),

                "Number_of_impact_stories": postings.filter_by_title('impact',

                startDate, endDate),

                "Number_of_missed_calls": callDetails.missedCalls(startDate,

                                                                  endDate),

                "Number_of_missed_calls_on_mobilink":

                callDetails.missedCalls(startDate, endDate, 'mobilink'),

                "Number_of_missed_calls_on_mobilinktata":

                callDetails.missedCalls(startDate, endDate,'mobilinktata'),

                "Number_of_calls_answered": callDetails.answeredCalls(startDate,

                endDate),

                "Number_of_calls_lasting_less_than_30_seconds": callDetails.filter_calls_by_duration(startDate, endDate, 30),

                "Average_length_of_calls": average_call_length,

                "Total_number_of_audio_minutes_played": str(audio_minutes),

                "Audio_minutes_on_channel": individual_audio_minutes(),

                "Load_on_channel": individual_load(),

                "Busiest_hour_for_mobilink": mobilink_load["maxLoad"],

                "Number_of_calls_in_busiest_hour_for_mobilink":

                mobilink_load["maxCalls"],

                "Least_active_hour_for_mobilink": mobilink_load["minLoad"],

                "Busiest_hour_for_mobilinktata": mobilink_tata_load["maxLoad"],

                "Number_of_calls_in_busiest_hour_for_mobilinktata":

                mobilink_tata_load["maxCalls"],

                "Least_active_hour_for_mobilinktata":

                mobilink_tata_load["minLoad"],

                "Number_of_calls_unanswered":

                callDetails.calls_unanswered(startDate, endDate),

                "Maximum_duration_of_unanswered_call":

                callDetails.max_duration_UC(startDate, endDate)

            })

def genReport():

    rep = genJSON()

    keys = rep.keys()

    template = ''

    for key in keys:

        if type(rep[key]) is dict:

            for item in rep[key]:

                rep[key][item] = str(rep[key][item])

        template+= key.replace('_', ' ') + ': ' + str(rep[key])  + '\n'

    return template

if args.mail is False:

    report = genReport()

    print report

else:

    report = genReport()

    subject = mailConfig.subject.format(startDate, endDate)

    report = mailConfig.text.format(startDate, endDate) + '\n' + report

    mail = gmail.GMail(mailConfig.username, mailConfig.password)

    message = gmail.Message(subject, mailConfig.to, mailConfig.cc, text=report)

    mail.send(message)