testy

import datetime
import random

from django.db.models import Min, Max, Sum
from django.test import TestCase
import json

from core.models import SupremeUser, Location, Store, ProcessedDailyVisits, GeoLocation, Category, Brand, VisitsSummary
from core.serializers import StoreSerializer
from django.utils import timezone
from rest_framework.request import Request
from rest_framework.test import APIRequestFactory, force_authenticate

WAIT_TIME = 10
STATUS_CODE_OK = 200


class CoreTest(TestCase):

    def setUp(self):
        print("SET UP")
        u = SupremeUser.objects.create_superuser(username='test', email="hehe@xD.co", password='test')
        u.save()
        self.client.force_login(u)
        factory = APIRequestFactory()
        request = factory.get('/api/token-auth')

        response = self.client.post('/api/token-auth/', {
            "username": "test",
            "password": "test"
        })
        self.assertEquals(response.status_code, 200)
        force_authenticate(request, user=u, token=response.data["token"])

    def add_geo_locations(self):
        g1 = GeoLocation.objects.create(region="reg1", country="c1")
        g1.save()
        g2 = GeoLocation.objects.create(region="reg2", country="c2")
        g2.save()

        g_data_from_api = self.client.get('/api/geo_locations/')
        self.assertEquals(g_data_from_api.status_code, 200)
        # print("Created two simple geo_locations and saved to database")
        correct_data_num = 0
        for g_data in g_data_from_api.data:
            numReg = 0
            numCountry = 0
            for key, value in g_data.items():
                if str(key) == "region":
                    if str(value) == "reg1":
                        numReg = 1
                    elif str(value) == "reg2":
                        numReg = 2
                if str(key) == "country":
                    if str(value) == "c1":
                        numCountry = 1
                    elif str(value) == "c2":
                        numCountry = 2
            self.assertEquals(numReg, numCountry)
            if (numReg == numCountry) and (numReg != 0):
                correct_data_num += 1
        self.assertEquals(correct_data_num, 2)
        # print("Checked correction of insertion geo_locations to database -> OK")

    def add_locations(self):
        # g_data_from_api = self.client.get('/api/geo_locations/')
        # geo_locations_urls = []
        # for g_data in g_data_from_api.data:
        #     for key, value in g_data.items():
        #         if str(key) == "url":
        #             geo_locations_urls.append(str(value))
        # print("Geo Locations URLs : ")
        # print(geo_locations_urls)
        g = GeoLocation.objects.all()
        self.assertEquals(len(g), 2)
        l1 = Location.objects.create(name="loc1", geo_location=g[0])
        l1.save()
        l2 = Location.objects.create(name="loc2", geo_location=g[1])
        l2.save()

        l_data_from_api = self.client.get('/api/locations/')
        self.assertEquals(l_data_from_api.status_code, 200)
        # print("Created two simple locations with previous geo_locations data")
        correct_data_num = 0
        for l_data in l_data_from_api.data:
            numLoc = 0
            numGeoLoc = 0
            for key, value in l_data.items():
                if str(key) == "name":
                    if str(value) == "loc1":
                        numLoc = 1
                    elif str(value) == "loc2":
                        numLoc = 2
                if str(key) == "geo_location":
                    # print("GEO LOCATION")
                    # print(value)
                    for key2, value2 in value.items():
                        # print("key2 = " + str(key2))
                        # print("value2 = " + str(value2))
                        if str(key2) == "region":
                            # print("region = " + str(value2) + ", gdy loc = " + str(numLoc))
                            for i in range(1, 3):
                                if str(value2) == "reg1":
                                    numGeoLoc = 1
                                elif str(value2) == "reg2":
                                    numGeoLoc = 2
            self.assertEquals(numLoc, numGeoLoc)
            if numLoc == numGeoLoc and numLoc != 0:
                correct_data_num += 1
        # print("I see there is " + str(correct_data_num) + " correct data in database (should be 2)")
        self.assertEquals(correct_data_num, 2)

    def add_categories(self):
        for i in range(20):
            active = False
            if i % 2 == 0:
                active = True
            cat = Category.objects.create(name="cat" + str(i), active=active)
            cat.save()

    def add_brands(self):
        for i in range(10):
            active = False
            if i % 2 == 0:
                active = True
            b = Brand.objects.create(name="brand" + str(i), active=active)
            b.save()

    def add_stores(self):
        brand = Brand.objects.all()
        locations = Location.objects.all()
        categories = Category.objects.all()
        # print("Len locations to ")
        # print(len(locations))
        # print(locations[0])
        # print(locations[1])
        for i in range(2):
            cat_set = set()
            for j in range(random.randint(0, len(categories))):
                randnum = random.randint(0, len(categories) - 1)
                cat_set.add(categories[randnum])
            # print("i = " + str(i))
            s = Store.objects.create(
                    type="type" + str(i),
                    name="name" + str(i),
                    floor=i,
                    brand=brand[i],
                    created_by="misio" + str(i),
                    updated_by="nobody" + str(i),
                    location=locations[i],
            )
            s.categories.set(cat_set)
            s.save()

    def add_processedDailyVisits(self):
        stores = Store.objects.all()
        for i in range(2):
            for days_num in range(20):
                pdv = ProcessedDailyVisits.objects.create(
                        day=datetime.datetime.now() - datetime.timedelta(days=days_num),
                        n_unique_customers=random.randint(1, 100),
                        store_id=stores[i]
                )
                pdv.save()

    def add_visitsSummary(self):
        stores = Store.objects.all()
        x = 0
        now = datetime.datetime.now()
        yesterday = now - datetime.timedelta(days=1)
        delta_30 = datetime.timedelta(days=30)
        delta_7 = datetime.timedelta(days=7)
        start_30 = now - delta_30
        start_7 = now - delta_7
        # print("yesterday : " + str(yesterday))
        # print("start_7 : " + str(start_7))
        for store in stores:
            vs = VisitsSummary.objects.get_or_create(store=store)
            new = vs[1]
            vs = vs[0]  # above returns pair (object, bool_if_created)
            if new:
                vs.created_time = timezone.now()

            delta = None
            delta_qs = store.processeddailyvisits_set.all().order_by('-day')
            if len(delta_qs) >= 3 and delta_qs[2].n_unique_customers > 0:
                delta = (delta_qs[1].n_unique_customers / delta_qs[2].n_unique_customers) - 1
                delta *= 100

            filtered_visits = store.processeddailyvisits_set.all().filter(day__gte=start_30, day__lte=yesterday)
            days = len(filtered_visits)
            min_daily_visits = filtered_visits.aggregate(Min('n_unique_customers'))
            max_daily_visits = filtered_visits.aggregate(Max('n_unique_customers'))
            total_visits = filtered_visits.aggregate(Sum('n_unique_customers'))
            if days > 0:
                vs.average_visits_last_30_days = int(total_visits['n_unique_customers__sum'] / days)
                vs.total_visits_last_30_days = total_visits['n_unique_customers__sum']
                vs.min_daily_visits_last_30_days = min_daily_visits['n_unique_customers__min']
                vs.max_daily_visits_last_30_days = max_daily_visits['n_unique_customers__max']
                vs.active_last_30_days = days

            filtered_visits = store.processeddailyvisits_set.all().filter(day__gte=start_7, day__lte=yesterday)
            days = len(filtered_visits)
            min_daily_visits = filtered_visits.aggregate(Min('n_unique_customers'))
            max_daily_visits = filtered_visits.aggregate(Max('n_unique_customers'))
            total_visits = filtered_visits.aggregate(Sum('n_unique_customers'))
            if days > 0:
                vs.average_visits_last_7_days = int(total_visits['n_unique_customers__sum'] / days)
                vs.total_visits_last_7_days = total_visits['n_unique_customers__sum']
                vs.min_daily_visits_last_7_days = min_daily_visits['n_unique_customers__min']
                vs.max_daily_visits_last_7_days = max_daily_visits['n_unique_customers__max']
                vs.active_last_7_days = days

            vs.updated_time = timezone.now()
            vs.delta = delta
            vs.save()
            store.visits_summary = vs
            store.save()
            x += 1

    def add_stores_to_user(self):
        stores = Store.objects.all()
        user = SupremeUser.objects.filter(username="test")[0]
        for store in stores:
            user.stores.add(store)

    def add_everything_needed(self):
        self.add_geo_locations()
        self.add_locations()
        self.add_categories()
        self.add_brands()
        self.add_stores()
        self.add_processedDailyVisits()
        self.add_visitsSummary()
        self.add_stores_to_user()

    def test_1(self):
        self.add_everything_needed()
        user = SupremeUser.objects.filter(username="test")[0]
        # print(user.stores.all())
        self.assertEquals(len(user.stores.all()), 2)

    def test_2(self):
        self.add_everything_needed()
        response = self.client.get('/api/users/')
        self.assertEquals(response.status_code, 200)
        # print(response.status_code)
        # print(response.data)
        username = ""
        stores_number = 0
        ok_data = 0
        for data in response.data:
            for key, value in data.items():
                if key == "username":
                    username = value
                if key == "stores":
                    stores_number = len(value)
            # print("username = " + username)
            # print("stores num = " + str(stores_number))
            if (username == "AnonymousUser" and stores_number == 0) or (username == "test" and stores_number == 2):
                ok_data += 1
        self.assertEquals(ok_data, 2)

    def test_3(self):
        self.add_everything_needed()
        response = self.client.get('/api/users/recent_stats/?days=7')
        # print(response.status_code)
        # print(response.data)
        user = SupremeUser.objects.filter(username="test")[0]
        total = 0
        for store in user.stores.all():
            # print("Store vs :")
            # print(store.visits_summary.total_visits_last_7_days)
            total += store.visits_summary.total_visits_last_7_days

        # print("total")
        # print(total)
        self.assertEquals(total, response.data['total_number_of_visits'])