import io
import os

import requests

from helix.calculators.calculator import Calculator
from helix.constants import redis_constant, sql_constant
from helix.constants.system_type import SystemType
from helix.csv_builder import CsvBuilder
from helix.doc_gen_params_builder import DocGenParamsBuilder
from helix.helpers.camel_case import convert_dict_keys_to_snake_case
from helix.json_builder import JsonBuilder
from helix.presenters.image_presenter import ImagePresenter
from helix.qa_helper import QAScenario, QAException
from helix.Services.doc_gen_service import DocGenService
from helix.Services.s3_helper import s3_upload
from helix.session_manager import SessionManager


def get_site_characterization_from_sales_force(helix_session_id, access_token, sfid):
    SFDC_API_URL = os.getenv('SFDC_API_URL', 'https://sunpower--qa.cs8.my.salesforce.com')
    url = SFDC_API_URL + '/services/apexrest/v1/HelixRoofDetails'
    headers = {'Authorization': 'Bearer {}'.format(access_token)}
    params = {'sfid': sfid, 'helix_session_id': helix_session_id}
    result = requests.get(url, headers=headers, params=params, timeout=30)
    if result.status_code == 200:
        data = result.json()
        if data:
            data = convert_sales_force_data_format_to_helix(data)
        return data, 200
    else:
        print('Error while getting data from Salesforce ({})'.format(result.status_code))
        print(url, params)
        print(result.content)
        # print(result.request.headers)
        return None, result.status_code


def convert_sales_force_data_format_to_helix(data):
    data = convert_dict_keys_to_snake_case(data)

    if data['system_type'] in ('Single-Tilt', 'Single Tilt'):
        data['system_type'] = SystemType.singleTilt.value
    elif data['system_type'] == ('Dual-Tilt', 'Dual Tilt'):
        data['system_type'] = SystemType.dualTilt.value

    if data['anchor_type'] == 'OMG Power Grip Plus':
        data['anchor_type'] = 'OMG PowerGrip Plus'

    data['ballast_block_weight'] = data['ballast_weight']
    data['max_system_pressure'] = data['max_psf'] = data['system_pressure']
    return data
    # data['spectral_response_acceleration']


def export_to_sfdc(helix_session_id, access_token, sfid, new_dxf_file=False, qa_test=None):
    step = 'Exporting to Salesforce'
    try:
        # 1. Load User Values
        step = 'Loading User Values'
        session = {'id': helix_session_id}
        db_session = sql_constant.sql_session_maker()
        session_manager = SessionManager(session, redis_constant.redis_store, db_session)
        user_values = session_manager.user_values()
        calculator = Calculator(user_values)

        # 2. Generate BOM CSV file
        step = 'Generating BOM'
        bom = calculator.compute_bom()
        csv_file = CsvBuilder().build_bom_output(bom)
        # 2.1 Generate BOM CSV file
        step = 'Generating BOM as JSON'
        json_builder = JsonBuilder()
        bom_list = json_builder.build_bom(bom)
        bom_list_json = json_builder.bom_to_json(bom_list)

        # 3. Generate DOCUMENTATION PDF file
        step = 'Generating Documentation'
        image_presenter = ImagePresenter(user_values.system_type(), user_values.module_type())
        doc_gen_service = DocGenService(requests, DocGenParamsBuilder(user_values, user_values.system_type(), calculator, image_presenter))
        document = doc_gen_service.generate() # Call external service

        # 4. Get Uploaded DXF file in the Helix system
        step = 'Loading uploaded DXF'
        dxf_contents = session_manager.site.dxf_file or session_manager.site.cad_file
        # dxf_filename = session_manager.site.dxf_file_name

        # 5. Save CSV/PDF/DXF files into AWS-S3
        step = 'Uploading to S3'
        if qa_test == QAScenario.SF_ERROR_UPLOAD_S3.value:
            raise QAException(qa_test)

        bom_csv_url = s3_upload(io.StringIO(csv_file), filename=sfid + '-csv.csv')
        doc_url = s3_upload(io.BytesIO(document), filename=sfid + '-pdf.pdf')
        bom_json_url = s3_upload(io.StringIO(bom_list_json), filename=sfid + '-json.json')
        # Send only if the file DXF file was uploaded in Helix
        if new_dxf_file and dxf_contents: # Optional
            dxf_url = s3_upload(io.StringIO(dxf_contents), filename=sfid + '-dxf.dxf')
        else:
            dxf_url = None

        # 6. Notify SFDC system with an API request
        step = 'Notifying Salesforce'
        if qa_test == QAScenario.SF_ERROR_NOTIFY_SF.value:
            raise QAException(qa_test)

        data = {
            'dxfUrl': dxf_url,
            'bomCsvUrl': bom_csv_url,
            'documentationUrl': doc_url,
            'bom': bom_list,
            'helixSessionId': helix_session_id,
            'sfid': sfid,
        }
        headers = {'Authorization': 'Bearer {}'.format(access_token)}
        SFDC_API_URL = os.getenv('SFDC_API_URL', 'https://sunpower--qa.cs8.my.salesforce.com')
        url = SFDC_API_URL + '/services/apexrest/v1/HelixRoofDetails'
        result = requests.post(url, headers=headers, json=data, timeout=30)
        # 7. Internal logs
        if result.status_code <= 299:
            print('Salesforce notified successfully for session {}.'.format(helix_session_id))
            # print(result.content)
            error = None
        else:
            error = 'Helix Calculator was not able to notify Salesforce ({})'.format(result.status_code)

            print(error)
            print(result.content)

        # Only Helix need this information for audit
        data['bomJsonUrl'] = bom_json_url

        db_session.close()
        return error, data
    except Exception as e:
        print('Error while {} for session {}'.format(step, helix_session_id))
        error = 'Error while {}'.format(step)
        return error, {}