from typing import Dict
import boto3
import json

from internal.helpers import rds_query
from internal.commons import BUCKET, s3_config, URL_EXPIRE

import logging
log = logging.getLogger()


##
# Post request filters
# handler(result) -> result
##


def sign_upload_url(result: Dict, req) -> Dict:
    req_params = {"Bucket": BUCKET['user'],
                  "Key": result["fileKey"],
                  "ContentType": "text/csv",
                  "ServerSideEncryption": "AES256"
                  }

    s3_client = boto3.client('s3',
                             config=s3_config)
    result["uploadUrl"] = s3_client.generate_presigned_url(ClientMethod="put_object",
                                                           Params=req_params,
                                                           ExpiresIn=URL_EXPIRE)
    del result['fileKey']
    result['collectionId'] = f"{req['workspace_schema']}-{result['collectionId']}"
    return result


def convert_chart_data_to_graphql(result, req):
    for chart in result:
        chart['__typename'] = chart['type']
        # perma-id coming from dataprocessor
        cid = chart['id']
        if chart['type'] in ['PieChart', 'BarChart', 'AreaChart', 'CalendarChart', 'Choropleth', 'ParetoChart']:
            for data in chart['data']:
                data['id'] = f"{cid}-{data['id']}"
        elif chart['type'] in ['StackChart', 'GroupChart', 'RadarChart']:
            for group in chart['data']:
                group['id'] = gid = f"{cid}-{group['id']}"
                for item in group['items']:
                    item['id'] = f"{gid}-{item['id']}"
        elif chart['type'] in ['TreeMap']:
            for data in chart['data']:
                data['id'] = f"{cid}-{data['id']}"
                data['parent'] = f"{cid}-{data['parent']}"
        elif chart['type'] in ['LineChart']:
            for graph in chart['data']:
                graph['id'] = gid = f"{cid}-{graph['id']}"
                for item in graph['graph']:
                    item['id'] = f"{gid}-{item['id']}"
        elif chart['type'] in ['InfoTabs']:
            for data in chart['data']:
                data['id'] = did = f"{cid}-{data['id']}"
                for item in data['items']:
                    item['id'] = f"{did}-{item['id']}"
    return result


def convert_analytics_groups_to_graphql(result, req):
    for group in result:
        group['charts'] = convert_chart_data_to_graphql(group['charts'], req)
    return result


def convert_filters_to_graphql(result, req):
    for filter in result:
        filter['__typename'] = 'Filter'
        # perma-id coming from dataprocessor
        fid = filter['id']
        if 'options' in filter:
            for option in filter['options']:
                option['id'] = f"{fid}-{option['id']}"
    return result


def convert_filter_groups_to_graphql(result, req):
    for group in result:
        group['filters'] = convert_filters_to_graphql(group['filters'], req)
    return result


def convert_single_audience(aud, req):
    if isinstance(aud, dict) and 'id' in aud:
        if aud.get('source') is not None:
            caw_schema = aud['source'].get('cawSchema')
            caw_type = aud['source'].get('cawType')
            alliance_id = caw_schema if caw_schema is not None and caw_type == 'alliance' else None
        else:
            alliance_id = req.get('alliance_schema', None)
        if alliance_id:
            aud['id'] = f"{alliance_id}-{aud['id']}"
            # parent_id is used to distinguish between Audeince and AudeienceExtended
            if 'parentId' in aud:
                aud['source'] = {'cawType': 'alliance',
                                 'cawId': alliance_id
                                 }
                if aud['parentId']:
                    aud['parentId'] = f"{alliance_id}-{aud['parentId']}"
                aud['source'] = {'cawType': 'alliance',
                                 'cawId': alliance_id
                                 }
                for meta in rds_query(f"SELECT key,val FROM {alliance_id}.meta_data WHERE key = 'name'"):
                    aud['source']['cawName'] = meta['val']
                    break
                else:
                    RuntimeError('Could not retrieve alliance name')
        else:
            if aud.get('source') is not None:
                caw_schema = aud['source'].get('cawSchema')
                caw_type = aud['source'].get('cawType')
                workspace_id = caw_schema if caw_schema is not None and caw_type == 'workspace' else None
            else:
                workspace_id = req.get('workspace_schema')
            aud['id'] = f"{workspace_id}-{aud['id']}"
            if 'parentId' in aud:
                if aud['parentId']:
                    aud['parentId'] = f"{workspace_id}-{aud['parentId']}"
                aud['source'] = {'cawId': workspace_id,
                                 'cawType': 'workspace',
                                 'cawName': 'default workspace'}
    return aud


def convert_audience_to_graphql(result, req):
    if isinstance(result, list):
        for aud in result:
            convert_single_audience(aud, req)
    else:
        convert_single_audience(result, req)

    return result


def convert_single_collection(coll, req):
    schema_id = (req['alliance_schema'] if 'alliance_schema' in req else None) or req['workspace_schema']
    if coll and 'id' in coll:
        coll['id'] = f"{schema_id}-{coll['id']}"
        if 'parentId' in coll and coll['parentId']:
            coll['parentId'] = f"{schema_id}-{coll['parentId']}"

    return coll


def convert_collections_to_graphql(result, req):
    if isinstance(result, list):
        for coll in result:
            convert_single_collection(coll, req)
    else:
        convert_single_collection(result, req)

    return result


def convert_pelias_response(result, req):
    if "geocoding" in result:
        del result["geocoding"]
    if "type" in result:
        del result["type"]
    return result