"""Methods specific to The Orchard."""
import pymysql

import backoff
import sqlalchemy

from integration_scripts.connectors.logging import logger
from integration_scripts.connectors import mysql

from integration_scripts import db_utils

from integration_scripts.sql.select_access_token_oa import \
    SELECT_ACCESS_TOKEN_OA
from integration_scripts.sql.select_access_token_alw import \
    SELECT_ACCESS_TOKEN_ALW


@backoff.on_exception(backoff.expo,
                      (pymysql.err.Error, sqlalchemy.exc.SQLAlchemyError),
                      max_tries=5, max_time=1200, max_value=300)
@mysql.ar_db_session_wrap
def get_user_id_alw(session, label_id):
    """Get an ALW user_id from a given label_id.

    Args:
        session: The wrapping session
        label_id (str): label_id for which to retrieve access token

    Returns:
        str
    """
    # Init vars
    params = {'vendor_id': label_id}
    sql = SELECT_ACCESS_TOKEN_ALW
    query_results = db_utils.run_query(session, sql=sql, params=params)
    result = None
    user_id = None

    for result in query_results:
        user_id = result['user_id']

    if not result:
        raise ValueError(
            'No ALW user_id available for label: {}'.format(label_id))

    return user_id


@backoff.on_exception(backoff.expo,
                      (pymysql.err.Error, sqlalchemy.exc.SQLAlchemyError),
                      max_tries=5, max_time=1200, max_value=300)
@mysql.ar_db_session_wrap
def get_access_token_alw(session, label_id):
    """Get an ALW access token from art_relations for a given label_id.

    Args:
        session: The wrapping session
        label_id (str): label_id for which to retrieve access token

    Returns:
        str
    """
    # Init vars
    params = {'vendor_id': label_id}
    sql = SELECT_ACCESS_TOKEN_ALW
    query_results = db_utils.run_query(session, sql=sql, params=params)
    access_token = None
    result = None

    for result in query_results:
        access_token = result['access_token']

    if not result:
        raise ValueError(
            'No ALW access_token available for label: {}'.format(label_id))

    return access_token


@backoff.on_exception(backoff.expo,
                      (pymysql.err.Error, sqlalchemy.exc.SQLAlchemyError),
                      max_tries=5, max_time=1200, max_value=300)
@mysql.ar_db_session_wrap
def get_access_token_oa(session, login):
    """Get the value of a single field from MySQL.

    Args:
        session: (SQLAlchemy)       Session from db wrapper
        user_id (str): user_id for which to retrieve access token

    Returns:
        str
    """
    if not login or login == 'None':
        raise ValueError(
            'No user id provided in environment: OA_USER_LOGIN')

    # Init vars
    params = {'login': login}
    sql = SELECT_ACCESS_TOKEN_OA
    query_results = db_utils.run_query(session, sql=sql, params=params)
    access_token = None
    result = None

    for result in query_results:
        access_token = result['access_token']

    if not result:
        raise ValueError(
            'No OA access_token available for user: {}'.format(login))

    return access_token


# TODO: Tests for both branches. Breaks if not using OA_USER_LOGIN? (likely)
def fetch_access_token(chunk_list, label_id=None, user_login=None):
    """Retrieve the correct access token for Bulk Upload access."""
    # If there is any data for this single label
    access_token = None

    if len(chunk_list) and len(chunk_list[0]):
        # Build Request Object for JSON
        if user_login:
            # OA Login
            logger.info('Fetching OA access token for {}.'.format(user_login))

            access_token = get_access_token_oa(login=user_login)

        elif label_id:  # ALW Login
            logger.info('Fetching ALW access token for {}.'.format(label_id))

            access_token = get_access_token_alw(label_id=label_id)

        else:
            raise ValueError('\'fetch_access_token()\' requires either a '
                             'label_id or a user_login')
    return access_token


def remap_transitional_territories(terr_list):
    """Remap transitional territories."""
    return_list = set()

    for i in terr_list:

        # ['AN','CS','FX','GZ','TP','ZZ']
        if i == 'AN':
            return_list.add('BQ')
            return_list.add('CW')
            return_list.add('SX')
        elif i == 'FX':
            return_list.add('FR')
        elif i == 'CS':
            return_list.add('ME')
            return_list.add('RS')
        elif i == 'GZ':
            return_list.add('PS')
        elif i == 'TP':
            return_list.add('TL')
        elif i == 'ZZ':
            pass
        else:
            return_list.add(i)

    return list(return_list)