#!/usr/bin/python
# -*- coding: utf-8 -*-     

import sys
import time
import datetime
import os
import json

from monitor_conf import *

TIME_LEN = 20
NEW_STH_STR = "STH updated"
START_STR = "Starting monitor"


def get_logs():
    logs = []
    for file in os.listdir("./" + OUTPUT_DIR):
        if file.endswith(".log"):
            logs.append(file)
    return logs

def get_age_from_line(line):
    past = datetime.datetime.strptime(line[:20], '%Y-%m-%d %H:%M:%S')
    present = datetime.datetime.now()
    return present - past

def read_loglog(filename):
    with open(OUTPUT_DIR + filename) as f:
        content = f.readlines()
    return content

def print_log_stats(l):
    log = read_loglog(l)
    rev_log = list(reversed(log))
    last = rev_log[0]

    # Stats from last STH update
    for item in rev_log:
        line = item[TIME_LEN:]
        if line[:len(START_STR)] == START_STR:
            break
        if line[:len(NEW_STH_STR)] == NEW_STH_STR:
            timestamp = datetime.datetime.strptime(line[-20:-1], '%Y-%m-%d %H:%M:%S')
            age = datetime.datetime.utcnow() - timestamp
            size = line.split("Size: ")[1].split(",")[0]
            # print line[:-1]
            print "STH age: " + str(age)[:-7]
            print "Tree Size: " + size
            break
    else:
        print "No STH update found in log."


def print_average_age(l):
    log = read_loglog(l)
    rev_log = list(reversed(log))
    # last = rev_log[0]

    prev_timestamp = None
    ages = []
    delays = []
    for item in rev_log:
        line = item[TIME_LEN:]
        if line[:len(START_STR)] == START_STR:
            # break
            prev_timestamp = None # Don't count over restarts
        if line[:len(NEW_STH_STR)] == NEW_STH_STR:
            timestamp = datetime.datetime.strptime(line[-20:-1], '%Y-%m-%d %H:%M:%S')
            time_seen = datetime.datetime.strptime(item[:TIME_LEN -1], '%Y-%m-%d %H:%M:%S')
            delays.append(time_seen - timestamp)
            if prev_timestamp is not None:
                ages.append(prev_timestamp - timestamp)
            prev_timestamp = timestamp

    if not len(delays) == 0:
        average_timedelta = sum(delays, datetime.timedelta(0)) / len(delays)
        print "Average publish delay: " + str(average_timedelta).split('.')[0] + " (" + str(len(delays)) + " values)"

    if not len(ages) == 0:
        average_timedelta = sum(ages, datetime.timedelta(0)) / len(ages)
        print "Average update time: " + str(average_timedelta).split('.')[0] + " (" + str(len(ages)) + " values)"

def print_errors(l):
    # print errors since last restart
    log = read_loglog(l)
    rev_log = list(reversed(log))

    prev_timestamp = None
    ages = []
    for item in rev_log:
        line = item[TIME_LEN:]
        if ERROR_STR in line:
            print item[:-1]
        if line[:len(START_STR)] == START_STR:
            break # comment this line to print all errors ever
            pass

def print_ips(l):
    log = read_loglog(l)
    ips = {}
    for item in log:
        if "New Front end IP" in item:
            ip = item.split()[-1]
            if not ip in ips:
                ips[ip] = item.split()[0]

    print str(len(ips)) + " front end IPs seen:"
    for i in ips:
        print i + " first seen " + ips[i]

def print_overlap(l):
    log = read_loglog(l)
    print "Log: ", log
    source = log[0].split("[")[0].split()[-1]
    print "\nOverlaps in " + source + ":"
    entry_count = {}
    metadata = {"unique":0, "valid":0}
    total = 0

    # Prune entries in the end
    while(not source in json.loads(log[-1].split("logs: ")[-1][:-1].replace("'", '"'))):
        log = log[:-1]

    for line in log:
        # line = item[TIME_LEN:]
        logs = json.loads(line.split("logs: ")[-1][:-1].replace("'", '"'))
        # if not source in logs: # don't check entries that were submitted after measurement start
        #     break
        if len(logs) == 1:
            metadata["unique"] += 1
        if "pilot" in logs or "rocketeer" in logs or "aviator" in logs:
            metadata["valid"] += 1

        for l in logs:
            if l in entry_count:
                entry_count[l] += 1
            else:
                entry_count[l] = 1
        total += 1
    
    # print entry_count
    for e in entry_count:
        if e != "plausible":
            print e + ", " + str(entry_count[e]) + " (" + str(int(100 * float(entry_count[e])/float(total))) + "%)"

    print ""
    for e in metadata:
        print e + ", " + str(metadata[e]) + " (" + str(int(100 * float(metadata[e])/float(total))) + "%)"

def write_history_data(l):
    if "overlap" in l:
        return

    logfile = OUTPUT_DIR + l[:-4] + "_history.txt"

    print "Looking for logfile..."
    if os.path.exists(logfile):
        os.remove(logfile)
        print "Removing " + logfile
    else:
        print "Could not find " + logfile



    log = read_loglog(l)
    data = {}
    start_date = datetime.date(2015, 9, 29)
    end_date = datetime.date(2015, 10, 20)

    # initialize with all dates
    for single_date in daterange(start_date, end_date):
        data[single_date.strftime("%Y-%m-%d")] = 0

    # parse log data
    for line in log:
        date = line[:TIME_LEN -10]
        try:
            size = line.split("STH updated. Size: ")[1].split(",")[0]
            data[date] = size
        except:
            pass

    # put in list and sort
    data_list = []
    for item in data:
        data_list.append((item, data[item]))
    data_list.sort(key=lambda tup: tup[0])

    # fill out missing data points and write to file
    with open(logfile, 'a') as f:
        prev_size = 0
        for item in data_list:
            s = str(item[0])

            if int(item[1]) > prev_size:
                val = int(item[1])
            else:
                val = prev_size

            if prev_size == 0:
                diff = 0
            else:
                diff = int(val) - int(prev_size)

            prev_size = val

            s += " " + str(val)
            s += " " + str(diff)
            s += "\n"
            f.write(s)
        f.close()



def daterange(start_date, end_date):
    for n in range(int ((end_date - start_date).days)):
        yield start_date + datetime.timedelta(n)


if __name__ == "__main__":
    OVERLAP_STR = "_overlap.log"
    logs = get_logs()
    for log in logs:
        if log == "monitor.log":
            pass
        # elif log[- len(OVERLAP_STR):] == OVERLAP_STR:
        #     print_overlap(log)
            pass
        else:
            pass
            print log
            print_log_stats(log)
            print_average_age(log)
            # print_errors(log)
            print_ips(log)
            print ""
            write_history_data(log)