#
# Business Logic for all Credit related activity
#
# Copyright 2010 Greek Research and Technology Network
#

from datetime import datetime
from django.db import transaction

from synnefo.db.models import Debit, FlavorCost

@transaction.commit_on_success
def debit_account(user , amount, vm, description):
    """Charges the user with the specified amount of credits for a vm (resource)"""
    date_now = datetime.now()
    user.credit = user.credit - amount
    user.save()

    # then write the debit entry
    debit = Debit()
    debit.user = user
    debit.vm = vm
    debit.when = date_now
    debit.description = description
    debit.save()


@transaction.commit_on_success
def credit_account(self, amount, creditor, description):
    """No clue :)"""
    return


@transaction.commit_on_success
def charge(vm):
    """Charges the owner of this VM.

    Charges the owner of a VM for the period
    from vm.charged to datetime.now(), based on the
    current operating state.

    """
    charged_states = ('STARTED', 'STOPPED')

    start_datetime = vm.charged
    vm.charged = datetime.now()

    # Only charge for a specific set of states
    if vm.operstate in charged_states:
        cost_list = []

        # remember, we charge only for Started and Stopped
        if vm.operstate == 'STARTED':
            cost_list = get_cost_active(vm.flavor, start_datetime, vm.charged)
        elif vm.operstate == 'STOPPED':
            cost_list = get_cost_inactive(vm.flavor, start_datetime, vm.charged)

        # find the total vost
        total_cost = sum([x[1] for x in cost_list])

        # add the debit entry
        description = "Server = %s, charge = %d for state: %s" % (vm.name, total_cost, vm.operstate)
        debit_account(vm.owner, total_cost, vm, description)

    vm.save()


def get_costs(vm, start_datetime, end_datetime, active):
    """Return a list with FlavorCost objects for the specified duration"""
    def between(enh_fc, a_date):
        """Checks if a date is between a FlavorCost duration"""
        if enh_fc.effective_from <= a_date and enh_fc.effective_to is None:
            return True

        return enh_fc.effective_from <= a_date and enh_fc.effective_to >= a_date

    # Get the related FlavorCost objects, sorted.
    price_list = FlavorCost.objects.filter(flavor=vm).order_by('effective_from')

    # add the extra field FlavorCost.effective_to
    for idx in range(0, len(price_list)):
        if idx + 1 == len(price_list):
            price_list[idx].effective_to = None
        else:
            price_list[idx].effective_to = price_list[idx + 1].effective_from

    price_result = []
    found_start = False

    # Find the affected FlavorCost, according to the
    # dates, and put them in price_result
    for p in price_list:
        if between(p, start_datetime):
            found_start = True
            p.effective_from = start_datetime
        if between(p, end_datetime):
            p.effective_to = end_datetime
            price_result.append(p)
            break
        if found_start:
            price_result.append(p)

    results = []

    # Create the list and the result tuples
    for p in price_result:
        if active:
            cost = p.cost_active
        else:
            cost = p.cost_inactive

        results.append( ( p.effective_from, calculate_cost(p.effective_from, p.effective_to, cost)) )

    return results


def calculate_cost(start_date, end_date, cost):
    """Calculate the total cost for the specified duration"""
    td = end_date - start_date
    sec = float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / float(10**6)
    total_hours = float(sec) / float(60.0*60.0)
    total_cost = float(cost)*total_hours

    return round(total_cost)


def get_cost_active(vm, start_datetime, end_datetime):
    """Returns a list with the active costs for the specified duration"""
    return get_costs(vm, start_datetime, end_datetime, True)


def get_cost_inactive(vm, start_datetime, end_datetime):
    """Returns a list with the inactive costs for the specified duration"""
    return get_costs(vm, start_datetime, end_datetime, False)