#!/usr/local/bin/python

# -*- coding: utf-8 -*-

"""

tim - A time recording tool, because time is money.

Author: Eugen Sawin (sawine@me73.com)

Dependencies: Python 2.7 and libsqlite3-dev

"""

import os

import sys

import argparse

from datetime import datetime

import db

WD = "working_path"

CONFIG = {WD: str}

CONFIG_SEP = "="

DB_FILE = "tim.db"

CURRENCIES = {("EUR", "EURO", "€"): "EUR",

("US DOLLAR", "USD", "$"): "USD"}

RATE_TYPES = {("h", "hourly"): "hourly"}

config = {}

# Try to get the user's home directory path

try: # Windows

	from win32com.shell import shellcon, shell

	HOMEDIR	= shell.SHGetFolderPath(0, shellcon.CSIDL_LOCAL_APPDATA, 0, 0)

except ImportError: # Linux (hopefully)

	HOMEDIR = os.path.expanduser("~")

CONFIG_FILE = "%s/.timrc" % HOMEDIR

DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"

def read_config():

	config = {}

	with open(CONFIG_FILE, "r") as config_stream:

		config_lines = [l.split(CONFIG_SEP) for l in config_stream.readlines() 

						if CONFIG_SEP in l]

		for key, value in config_lines:

			key = key.strip().lower()

			value = value.strip()

			if key in CONFIG:

				config[key] = CONFIG[key](value)

	return config

def write_config(config):

	with open(CONFIG_FILE, "w") as config_input:

		config_input.write("\n".join([CONFIG_SEP.join((k, v)) 

							for k, v in config.iteritems() if k in CONFIG]))

def db_file():

	global config

	if WD not in config:

		print "Working directory path is not configured. \

Please use the init command."

		return None

	return config[WD] + "/" + DB_FILE

def init(args):

	global config

	last_wd = None

	if WD in config:

		last_wd = config[WD]

	config[WD] = args.working_path

	write_config(config)

	path_exists = os.path.exists(config[WD]) and os.path.isdir(config[WD])

	db_exists = path_exists and os.path.exists(db_file())\

				and os.path.isfile(db_file())

	if last_wd != config[WD]:		

		print "Changed working directory from %s to %s." % (last_wd, config[WD])

	else:

		print "Working directory remains at %s." % config[WD]

	if not path_exists:

		print "Warning: working directory %s does not exist." % config[WD]

		os.makedirs(config[WD])

		print "Working directory %s created." % config[WD]

	elif db_exists:

		print "Database file %s already exists, please delete it before \

initiating a new database at this location." % db_file()

	if not db_exists:

		db.init(db_file())	

def parse_label(label):

	label = label.strip()

	if ":" in label:

		project, activity = label.split(":")

	else:

		project, activity = (label, None)

	return project, activity

def begin(args):

	project, activity = parse_label(args.label)

	time = datetime.now()

	db.resume(db_file(), None, None, time)

	db.begin(db_file(), project, activity, time)	

def end(args):

	project, activity = parse_label(args.label)

	log = args.m	

	time = datetime.now()

	db.resume(db_file(), db.find_active_task(db_file()), time, log)

	db.end(db_file(), project, activity, time, log)	

def pause(args):

	db.pause(db_file(), datetime.now())	 

def resume(args):

	db.resume(db_file(), None, datetime.now(), args.m)	

def add_task(args):

	project, activity = parse_label(args.label)

	log = args.m

	begin = datetime.strptime(args.begin, DATETIME_FORMAT)

	end = datetime.strptime(args.end, DATETIME_FORMAT)

	db.begin(db_file(), project, activity, begin)

	db.end(db_file(), project, activity, end, log)

def add_break(args):

	log = args.m

	begin = datetime.strptime(args.begin, DATETIME_FORMAT)

	end = datetime.strptime(args.end, DATETIME_FORMAT)

	db.pause(db_file(), begin)

	db.resume(db_file(), db.find_active_task(db_file(), begin), end, log)

def set_customer(args):

	db.update_where(db_file(), "projects", "name", args.project, "customer", 

				args.customer)

def map_name(map_base, name):

	mapped = None

	if name not in map_base.itervalues():

		for v in map_base.iterkeys():

			if name in v:

				mapped = map_base[v]

	else:

		mapped = name

	return mapped

def set_rate(args):

	project, activity = parse_label(args.label)

	currency = map_name(CURRENCIES, args.currency)

	type = map_name(RATE_TYPES, args.type)

	print "setting rate for %s at %f %s %s" % (project, args.rate, currency, type)

	db.set_rate(db_file(), project, activity, args.rate, currency, type)

def status(args):

	task = db.status(db_file())

	if task:

		print "Currently active task"

		print "Project: %s Activity: %s" % task

	else:

		print "There is no active task."

def main():

	global config

	config = read_config()

	parser = argparse.ArgumentParser(description="Records time.")

	subs = parser.add_subparsers()

	sub_init = subs.add_parser("init")

	sub_init.add_argument("working_path")

	sub_init.set_defaults(func=init)

	sub_begin = subs.add_parser("begin")

	sub_begin.add_argument("label")

	sub_begin.set_defaults(func=begin)

	sub_end = subs.add_parser("end")

	sub_end.add_argument("label", nargs="?", default="all:all")

	sub_end.add_argument("-m")

	sub_end.set_defaults(func=end)

	sub_pause = subs.add_parser("pause")

	sub_pause.set_defaults(func=pause)

	sub_resume = subs.add_parser("resume")

	sub_resume.add_argument("-m")

	sub_resume.set_defaults(func=resume)

	sub_add = subs.add_parser("add")

	sub_add_subs = sub_add.add_subparsers()

	sub_add_task = sub_add_subs.add_parser("task")

	sub_add_task.add_argument("label")

	sub_add_task.add_argument("begin")

	sub_add_task.add_argument("end")

	sub_add_task.add_argument("-m")

	sub_add_task.set_defaults(func=add_task)

	sub_add_break = sub_add_subs.add_parser("break")

	sub_add_break.add_argument("begin")

	sub_add_break.add_argument("end")

	sub_add_break.add_argument("-m")

	sub_add_break.set_defaults(func=add_break)

	sub_set = subs.add_parser("set")

	sub_set_subs = sub_set.add_subparsers()

	sub_set_customer = sub_set_subs.add_parser("customer")

	sub_set_customer.add_argument("project")

	sub_set_customer.add_argument("customer")

	sub_set_customer.set_defaults(func=set_customer)

	sub_set_rate = sub_set_subs.add_parser("rate")

	sub_set_rate.add_argument("label")

	sub_set_rate.add_argument("rate", type=float)

	sub_set_rate.add_argument("currency")

	sub_set_rate.add_argument("type")

	sub_set_rate.set_defaults(func=set_rate)

	sub_status = subs.add_parser("status")

	sub_status.set_defaults(func=status)

	args = parser.parse_args()

	args.func(args)

if __name__ == "__main__":

	main()