from datetime import datetime, timedelta

import pytest

from ordr3.repo import AbstractOrderRepository


class FakeOrderRepository(AbstractOrderRepository):
    """ Repository implementation for testing """

    def __init__(self, session):
        self._orders = set()

    def add_order(self, order):
        """ add an order to the datastore """
        self._orders.add(order)

    def get_order(self, reference):
        """ retrieve an order from the datastore """
        return next(o for o in self._orders if o.id == reference)

    def list_orders(self):
        return sorted(self._orders, reverse=True, key=lambda x: x.created_on)


@pytest.fixture
def prefilled_repo():
    from itertools import count
    from ordr3.models import OrderItem, OrderStatus

    i = count()
    catalog = {
        1: "Ethanol",
        2: "Aceton",
        3: "NaOH",
        4: "Coffee",
        5: "Water",
    }

    def _create_order(item, date, status):
        order = OrderItem(next(i), catalog[item], item, "", "", "", "", "")
        order.created_on = date
        order.status = status
        return order

    month = timedelta(days=30)
    today = datetime.now()

    repo = FakeOrderRepository(session=None)
    # should be consumables
    repo.add_order(_create_order(1, today - month * 1, OrderStatus.ORDERED))
    repo.add_order(_create_order(1, today - month * 2, OrderStatus.ORDERED))
    repo.add_order(_create_order(1, today - month * 3, OrderStatus.COMPLETED))
    repo.add_order(_create_order(2, today - month * 1, OrderStatus.ORDERED))
    repo.add_order(_create_order(2, today - month * 2, OrderStatus.ORDERED))
    repo.add_order(_create_order(2, today - month * 3, OrderStatus.COMPLETED))
    # no consumable, only two repeats
    repo.add_order(_create_order(3, today - month * 1, OrderStatus.ORDERED))
    repo.add_order(_create_order(3, today - month * 2, OrderStatus.ORDERED))
    # no consumable, only two repeats in the last two years
    repo.add_order(_create_order(4, today - month * 1, OrderStatus.ORDERED))
    repo.add_order(_create_order(4, today - month * 2, OrderStatus.ORDERED))
    repo.add_order(_create_order(4, today - month * 50, OrderStatus.ORDERED))
    # no consumable, one order on hold
    repo.add_order(_create_order(5, today - month * 1, OrderStatus.ORDERED))
    repo.add_order(_create_order(5, today - month * 2, OrderStatus.ORDERED))
    repo.add_order(_create_order(5, today - month * 3, OrderStatus.HOLD))

    return repo


def test_service_find_consumables(prefilled_repo):
    from ordr3.services import find_consumables

    result = find_consumables(prefilled_repo)

    assert len(result) == 2
    assert [o.id for o in result] == [3, 0]


def test_create_log_entry(prefilled_repo):
    from ordr3.services import create_log_entry
    from ordr3.models import OrderStatus, User

    order = prefilled_repo.get_order(1)
    user = User(*list("ABCDEFG"))

    create_log_entry(order, OrderStatus.APPROVAL, user)

    assert len(order.log) == 1
    log_entry = order.log[0]
    assert log_entry.order_id == order.id
    assert log_entry.status == OrderStatus.APPROVAL
    assert log_entry.by == "B"
    assert log_entry.user_id == "A"
    assert isinstance(log_entry.date, datetime)
    assert order.status == log_entry.status
    assert order.created_by == log_entry.by
    assert order.created_on == log_entry.date