from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

from .statements import *

nu = datetime.datetime.now()

from rowers.tasks import handle_getagegrouprecords

from rowers.utils import calculate_age

import rowers.dataprep as dataprep

@override_settings(TESTING=True)
class CPChartTest(TestCase):
    def setUp(self):
        self.u = UserFactory()

        self.r = Rower.objects.create(user=self.u,
                                      birthdate=faker.profile()['birthdate'],
                                      gdproptin=True, ftpset=True,surveydone=True,sex='male',
                                      weightcategory='hwt',
                                      gdproptindate=timezone.now(),
                                      rowerplan='pro')

        r = self.u.rower
        age = calculate_age(r.birthdate)
        self.c = Client()
        self.user_workouts = WorkoutFactory.create_batch(5, user=self.r)
        self.factory = RequestFactory()
        self.password = faker.word()
        self.u.set_password(self.password)
        self.u.save()

        recordsdf = pd.read_csv('rowers/tests/worldrecords.csv',encoding='utf-8')

        for i in recordsdf.index:
            record = C2WorldClassAgePerformance(
                name = recordsdf.loc[i,'name'],
                age = recordsdf.loc[i,'age'],
                distance = recordsdf.loc[i,'distance'],
                duration = recordsdf.loc[i,'duration'],
                power = recordsdf.loc[i,'power'],
                season = recordsdf.loc[i,'season'],
                sex = recordsdf.loc[i,'sex'],
                weightcategory = recordsdf.loc[i,'weightcategory'],
            )

            record.save()

        perfsdf = pd.read_csv('rowers/tests/testdata/calcageperformance.csv')

        r = self.u.rower

        for i in perfsdf.index:
            perf = CalcAgePerformance(
                age = age,
                duration = perfsdf.loc[i,'duration'],
               power = perfsdf.loc[i,'power'],
                sex = r.sex,
                weightcategory = r.weightcategory
                )
            perf.save()

    def tearDown(self):
        for workout in self.user_workouts:
            try:
                os.remove(workout.csvfilename)
            except (IOError, FileNotFoundError,OSError):
                pass

    def test_analytics_page(self):
        login = self.c.login(username=self.u.username,password=self.password)
        self.assertTrue(login)

        url = '/rowers/analysis/'

        response = self.c.get(url)
        self.assertEqual(response.status_code, 200)

    @patch('rowers.dataprep.create_engine')
    def test_addmanual(self, mocked_sqlalchemy):
        login = self.c.login(username=self.u.username,password=self.password)
        self.assertTrue(login)


        form_data = {
            'name': faker.word(),
            'date': nu.date(),
            'starttime': '10:01:43',
            'timezone': 'UTC',
            'duration': '00:02:00.0',
            'distance': 500,
            'workouttype': 'rower',
            'boattype': '1x',
            'boatname': 'CatchUp',
            'empowerside': 'starboard',
            'seatnumber': 1,
            'weightcategory': 'hwt',
            'adaptiveclass': 'None',
            'notes': faker.text(),
            'rankingpiece': True,
            'duplicate': False,
            'avghr': '160',
            'avgpwr': 0,
            'rpe':4,
            'avgspm': 40,
            }

        form = MetricsForm(form_data)
        self.assertTrue(form.is_valid())

        form = WorkoutForm(form_data)
        self.assertTrue(form.is_valid())


        url = '/rowers/workout/addmanual/'
        response = self.c.get(url)

        self.assertEqual(response.status_code,200)

        response = self.c.post(url, form_data, follow=True)
        self.assertEqual(response.status_code,200)

        workout_expected_id = 6

        self.assertRedirects(response,
                             expected_url='/rowers/workout/{id}/edit/'.format(
                                 id=encoder.encode_hex(workout_expected_id)),
                             status_code=302,target_status_code=200)

        # add some tests of complex form data (no hr, no spm, zero spm, etc)

    @patch('rowers.dataprep.create_engine')
    def test_agerecords(self, mock_sqlalchemy):
        #        update_records(url='rowers/tests/c2worldrecords.html',verbose=False)

        r = self.u.rower
        age = calculate_age(r.birthdate)

        wcdurations = []
        wcpower = []
        durations = [1,4,30,60]
        distances = [100,500,1000,2000,5000,6000,10000,21097,42195]

        df = pd.DataFrame(
            list(
                C2WorldClassAgePerformance.objects.filter(
                    sex=r.sex,
                    weightcategory=r.weightcategory
                ).values()
            )
        )

        jsondf = df.to_json()

        result = handle_getagegrouprecords(
            jsondf,distances,durations,age,r.sex,r.weightcategory)

        self.assertEqual(result,1)

        url = '/rowers/agegrouprecords/{sex}/{weightc}/2000m/'.format(
            sex = r.sex,
            weightc = r.weightcategory)

        response = self.c.get(url)
        self.assertEqual(response.status_code,200)