import csv
import json
import requests
import random
import os
import unittest

from apitest.pzbs import PzbsCalculator
from apitest.api import ApiCalculator

def runTest(tester, params):
    request=tester.get_request(*params)
    response=tester.get_response(
        requests.post(
            tester.get_url(),
            data=request
        ).text)
    print json.dumps(request)
    print json.dumps(response)
    return response

class ApiTestCase(unittest.TestCase):
    def __setupParams(self):
        csv_files = []
        for root, dirs, files in os.walk('./csv'):
            csv_files += [os.path.join(root, f) for f in files if f.lower().endswith('.csv')]
        self.params = []
        for csv_file in csv_files:
            csv_content = csv.reader(open(csv_file), delimiter=";")
            param_contents = [
                row for idx, row in enumerate(csv_content) if idx == 2][0]
            self.params.append((
                param_contents[0][0].lower(),
                None, 0,
                int(param_contents[1]), float(param_contents[4])))

    def setUp(self):
        self.pzbs = PzbsCalculator()
        self.api = ApiCalculator()
        self.__setupParams()
        self.longMessage=True
        self.maxDiff = None

    def test_csvCases(self):
        for params in self.params:
            for rank in ApiCalculator.ranks.keys():
                for boards in [0, 1]:
                    p = (params[0], rank, boards, params[3], params[4])
                    self.assertEqual(
                        runTest(self.pzbs, p),
                        runTest(self.api, p),
                        msg=str(p))

    def test_randomCases(self):
        for i in range(0, 20):
            for type in ['t', 'p', 'i']:
                for rank in ApiCalculator.ranks.keys():
                    for boards in [0, 1]:
                        p = (type, rank, boards,
                             random.randint(6, 350),
                             random.randint(0, 4000) / 2.0)
                        runTest(self.api, p)
                        #self.assertEqual(
                        #    runTest(self.pzbs, p),
                        #    runTest(self.api, p),
                        #    msg=str(p))

    def test_customParamCases(self):
        for type in ['t', 'p', 'i']:
            for rank in ApiCalculator.ranks.keys():
                for boards in [0, 1]:
                    for j in range(0, 20):
                        manualParams = {
                            'points': random.randint(20, 100)
                        }
                        p = (type, rank, boards,
                             35, 400, manualParams)
                        runTest(self.api, p)
                        #self.assertEqual(
                        #    runTest(self.pzbs, p),
                        #    runTest(self.api, p),
                        #    msg=str(p))
                    for j in range(0, 20):
                        manualParams = {
                            'weight': random.randint(20, 100)
                        }
                        p = (type, rank, boards,
                             35, 400, manualParams)
                        runTest(self.api, p)
                        #self.assertEqual(
                        #    runTest(self.pzbs, p),
                        #    runTest(self.api, p),
                        #    msg=str(p))
                    for j in range(0, 20):
                        manualParams = {
                            'players': random.randint(20, 100) * 0.001
                        }
                        p = (type, rank, boards,
                             35, 400, manualParams)
                        runTest(self.api, p)
                        #self.assertEqual(
                        #    runTest(self.pzbs, p),
                        #    runTest(self.api, p),
                        #    msg=str(p))
                    for j in range(0, 20):
                        manualParams = {
                            'cutoff': [
                                [random.uniform(0.04, 0.06),
                                 random.uniform(0.7, 0.9)],
                                [random.uniform(0.15, 0.35),
                                 random.uniform(0.15, 0.35)],
                                [random.uniform(0.4, 0.6),
                                 0.0]
                            ]
                        }
                        p = (type, rank, boards,
                             random.randint(20, 25),
                             random.randint(300, 400) / 2.0,
                             manualParams)
                        runTest(self.api, p)
                        #self.assertEqual(
                        #    runTest(self.pzbs, p),
                        #    runTest(self.api, p),
                        #    msg=str(p))