from rowers.tasks import handle_strava_sync, fetch_strava_workout
from stravalib.exc import ActivityUploadFailed, TimeoutExceeded
from rowers.rower_rules import is_workout_user, ispromember
from rowers.utils import get_strava_stream
from rowers.utils import dologging
from rowers.imports import *
from rowsandall_app.settings import (
    C2_CLIENT_ID, C2_REDIRECT_URI, C2_CLIENT_SECRET,
    STRAVA_CLIENT_ID, STRAVA_REDIRECT_URI, STRAVA_CLIENT_SECRET,
    SITE_URL
)
import gzip
import rowers.mytypes as mytypes
from rowers.utils import myqueue
from iso8601 import ParseError
import stravalib
from rowers.dataprep import columndict

# All the functionality needed to connect to Strava
from scipy import optimize
from scipy.signal import savgol_filter
import time
from time import strftime


import django_rq
queue = django_rq.get_queue('default')
queuelow = django_rq.get_queue('low')
queuehigh = django_rq.get_queue('low')


try:
    from json.decoder import JSONDecodeError
except ImportError:  # pragma: no cover
    JSONDecodeError = ValueError


webhookverification = "kudos_to_rowing"
webhooklink = SITE_URL+'/rowers/strava/webhooks/'

headers = {'Accept': 'application/json',
           'Api-Key': STRAVA_CLIENT_ID,
           'Content-Type': 'application/json',
           'user-agent': 'sanderroosendaal'}


oauth_data = {
    'client_id': STRAVA_CLIENT_ID,
    'client_secret': STRAVA_CLIENT_SECRET,
    'redirect_uri': STRAVA_REDIRECT_URI,
    'autorization_uri': "https://www.strava.com/oauth/authorize",
    'content_type': 'application/json',
    'tokenname': 'stravatoken',
    'refreshtokenname': 'stravarefreshtoken',
    'expirydatename': 'stravatokenexpirydate',
    'bearer_auth': True,
    'base_url': "https://www.strava.com/oauth/token",
    'grant_type': 'refresh_token',
    'headers': headers,
    'scope': 'activity:write,activity:read_all',
}


# Exchange access code for long-lived access token
def get_token(code):
    return imports_get_token(code, oauth_data)


def strava_open(user):
    t = time.localtime()
    timestamp = time.strftime('%b-%d-%Y_%H%M', t)
    with open('strava_open.log', 'a') as f:
        f.write('\n')
        f.write(timestamp)
        f.write(' ')
        f.write('Getting token for user ')
        f.write(str(user.rower.id))
        f.write(' token expiry ')
        f.write(str(user.rower.stravatokenexpirydate))
        f.write(' ')
        f.write(json.dumps(oauth_data))
        f.write('\n')
    token = imports_open(user, oauth_data)
    if user.rower.strava_owner_id == 0:  # pragma: no cover
        _ = set_strava_athlete_id(user)
    return token


def do_refresh_token(refreshtoken):
    return imports_do_refresh_token(refreshtoken, oauth_data)


def rower_strava_token_refresh(user):
    r = Rower.objects.get(user=user)
    res = do_refresh_token(r.stravarefreshtoken)
    access_token = res[0]
    expires_in = res[1]
    refresh_token = res[2]
    expirydatetime = timezone.now()+timedelta(seconds=expires_in)

    r.stravatoken = access_token
    r.stravatokenexpirydate = expirydatetime
    r.stravarefreshtoken = refresh_token
    r.save()

    return r.stravatoken

# Make authorization URL including random string


def make_authorization_url(request):  # pragma: no cover
    return imports_make_authorization_url(oauth_data)


def strava_establish_push():  # pragma: no cover
    url = "https://www.strava.com/api/v3/push_subscriptions"
    post_data = {
        'client_id': STRAVA_CLIENT_ID,
        'client_secret': STRAVA_CLIENT_SECRET,
        'callback_url': webhooklink,
        'verify_token': webhookverification,
    }

    response = requests.post(url, data=post_data)

    return response.status_code


def strava_list_push():  # pragma: no cover
    url = "https://www.strava.com/api/v3/push_subscriptions"
    params = {
        'client_id': STRAVA_CLIENT_ID,
        'client_secret': STRAVA_CLIENT_SECRET,

    }
    response = requests.get(url, params=params)

    if response.status_code == 200:
        data = response.json()
        return [w['id'] for w in data]
    return []


def strava_push_delete(id):  # pragma: no cover
    url = "https://www.strava.com/api/v3/push_subscriptions/{id}".format(id=id)
    params = {
        'client_id': STRAVA_CLIENT_ID,
        'client_secret': STRAVA_CLIENT_SECRET,
    }
    response = requests.delete(url, json=params)
    return response.status_code


def set_strava_athlete_id(user):
    r = Rower.objects.get(user=user)
    if (r.stravatoken == '') or (r.stravatoken is None):  # pragma: no cover
        s = "Token doesn't exist. Need to authorize"
        return custom_exception_handler(401, s)
    elif (r.stravatokenexpirydate is None or timezone.now()+timedelta(seconds=3599) > r.stravatokenexpirydate):
        _ = imports_open(user, oauth_data)

    authorizationstring = str('Bearer ' + r.stravatoken)
    headers = {'Authorization': authorizationstring,
               'user-agent': 'sanderroosendaal',
               'Content-Type': 'application/json'}
    url = "https://www.strava.com/api/v3/athlete"

    response = requests.get(url, headers=headers, params={})

    if response.status_code == 200:  # pragma: no cover
        r.strava_owner_id = response.json()['id']
        r.save()
        return response.json()['id']

    return 0


# Get list of workouts available on Strava
def get_strava_workout_list(user, limit_n=0):
    r = Rower.objects.get(user=user)

    if (r.stravatoken == '') or (r.stravatoken is None):  # pragma: no cover
        s = "Token doesn't exist. Need to authorize"
        return custom_exception_handler(401, s)
    elif (
        r.stravatokenexpirydate is None or timezone.now()+timedelta(seconds=3599) > r.stravatokenexpirydate
    ):  # pragma: no cover
        s = "Token expired. Needs to refresh."
        return custom_exception_handler(401, s)
    else:
        # ready to fetch. Hurray
        authorizationstring = str('Bearer ' + r.stravatoken)
        headers = {'Authorization': authorizationstring,
                   'user-agent': 'sanderroosendaal',
                   'Content-Type': 'application/json'}

        url = "https://www.strava.com/api/v3/athlete/activities"

        if limit_n == 0:
            params = {}
        else:  # pragma: no cover
            params = {'per_page': limit_n}

        s = requests.get(url, headers=headers, params=params)

    return s


def async_get_workout(user, stravaid):
    try:
        _ = strava_open(user)
    except NoTokenError:  # pragma: no cover
        return 0

    csvfilename = 'media/{code}_{stravaid}.csv'.format(
        code=uuid4().hex[:16], stravaid=stravaid)
    job = myqueue(queue,
                  fetch_strava_workout,
                  user.rower.stravatoken,
                  oauth_data,
                  stravaid,
                  csvfilename,
                  user.id,
                  )
    return job

# Get a Strava workout summary data and stroke data by ID


def get_workout(user, stravaid, do_async=True):
    return async_get_workout(user, stravaid)


# Generate Workout data for Strava (a TCX file)
def createstravaworkoutdata(w, dozip=True):
    filename = w.csvfilename
    try:
        row = rowingdata(csvfile=filename)
    except IOError:  # pragma: no cover
        data = dataprep.read_df_sql(w.id)
        try:
            datalength = len(data)
        except AttributeError:
            datalength = 0

        if datalength != 0:
            data.rename(columns=columndict, inplace=True)
            _ = data.to_csv(w.csvfilename+'.gz',
                            index_label='index',
                            compression='gzip')
            try:
                row = rowingdata(csvfile=filename)
            except IOError:
                return '', 'Error - could not find rowing data'
        else:
            return '', 'Error - could not find rowing data'

    tcxfilename = filename[:-4]+'.tcx'
    try:
        newnotes = w.notes+'\n from '+w.workoutsource+' via rowsandall.com'
    except TypeError:
        newnotes = 'from '+w.workoutsource+' via rowsandall.com'

    row.exporttotcx(tcxfilename, notes=newnotes)
    if dozip:
        gzfilename = tcxfilename+'.gz'
        with open(tcxfilename, 'rb') as inF:
            s = inF.read()
            with gzip.GzipFile(gzfilename, 'wb') as outF:
                outF.write(s)

        try:
            os.remove(tcxfilename)
        except WindowError:  # pragma: no cover
            pass

        return gzfilename, ""

    return tcxfilename, ""


# Upload the TCX file to Strava and set the workout activity type
# to rowing on Strava
def handle_stravaexport(f2, workoutname, stravatoken, description='',
                        activity_type='Rowing', quick=False, asynchron=False):
    # w = Workout.objects.get(id=workoutid)
    client = stravalib.Client(access_token=stravatoken)

    act = client.upload_activity(f2, 'tcx.gz', name=workoutname)

    try:
        if quick:  # pragma: no cover
            res = act.wait(poll_interval=2.0, timeout=10)
            message = 'Workout successfully synchronized to Strava'
        else:
            res = act.wait(poll_interval=5.0, timeout=30)
            message = 'Workout successfully synchronized to Strava'
    except:  # pragma: no cover
        res = 0
        message = 'Strava upload timed out'

    # description doesn't work yet. Have to wait for stravalib to update
    if res:
        try:
            act = client.update_activity(
                res.id, activity_type=activity_type, description=description, device_name='Rowsandall.com')
        except TypeError:  # pragma: no cover
            act = client.update_activity(
                res.id, activity_type=activity_type, description=description)
    else:  # pragma: no cover
        message = 'Strava activity update timed out.'
        return (0, message)

    return (res.id, message)


def workout_strava_upload(user, w, quick=False, asynchron=True):
    try:
        _ = strava_open(user)
    except NoTokenError:  # pragma: no cover
        return "Please connect to Strava first", 0

    message = "Uploading to Strava"
    stravaid = -1
    r = Rower.objects.get(user=user)
    res = -1
    if (r.stravatoken == '') or (r.stravatoken is None):  # pragma: no cover
        raise NoTokenError("Your hovercraft is full of eels")

    if (is_workout_user(user, w)):
        if asynchron:
            tcxfile, tcxmesg = createstravaworkoutdata(w)
            if not tcxfile:  # pragma: no cover
                return "Failed to create workout data", 0
            activity_type = r.stravaexportas
            if r.stravaexportas == 'match':
                try:
                    activity_type = mytypes.stravamapping[w.workouttype]
                except KeyError:  # pragma: no cover
                    activity_type = 'Rowing'
            _ = myqueue(queue,
                        handle_strava_sync,
                        r.stravatoken,
                        w.id,
                        tcxfile, w.name, activity_type,
                        w.notes)
            dologging('strava_export_log.log', 'Exporting as {t} from {w}'.format(
                t=activity_type, w=w.workouttype))
            return "Asynchronous sync", -1
        try:
            tcxfile, tcxmesg = createstravaworkoutdata(w)
            if tcxfile:
                activity_type = r.stravaexportas
                if r.stravaexportas == 'match':
                    try:
                        activity_type = mytypes.stravamapping[w.workouttype]
                    except KeyError:  # pragma: no cover
                        activity_type = 'Rowing'

                with open(tcxfile, 'rb') as f:
                    try:
                        description = w.notes+'\n from '+w.workoutsource+' via rowsandall.com'
                    except TypeError:
                        description = ' via rowsandall.com'
                    res, mes = handle_stravaexport(
                        f, w.name,
                        r.stravatoken,
                        description=description,
                        activity_type=activity_type, quick=quick, asynchron=asynchron)
                    if res == 0:  # pragma: no cover
                        message = mes
                        w.uploadedtostrava = -1
                        stravaid = -1
                        w.save()
                        try:
                            os.remove(tcxfile)
                        except WindowsError:
                            pass
                        return message, stravaid

                    w.uploadedtostrava = res
                    w.save()
                    try:
                        os.remove(tcxfile)
                    except WindowsError:  # pragma: no cover
                        pass
                    message = mes
                    stravaid = res
                    return message, stravaid
            else:  # pragma: no cover
                message = "Strava TCX data error "+tcxmesg
                w.uploadedtostrava = -1
                stravaid = -1
                w.save()
                return message, stravaid

        except ActivityUploadFailed as e:  # pragma: no cover
            message = "Strava Upload error: %s" % e
            w.uploadedtostrava = -1
            stravaid = -1
            w.save()
            os.remove(tcxfile)
            return message, stravaid
    return message, stravaid  # pragma: no cover