from flask_restful import Resource, reqparse
from flask import jsonify, render_template, make_response
from app import db
import requests
import datetime
import constants as const
import html_strings as temp
import calendar


from flask_restful import Resource, reqparse
from flask import jsonify, render_template, make_response
from app import db
import requests
import datetime
import constants as const
import html_strings as temp
import calendar
import random


class Report(Resource):
    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('account_number')
        # parser.add_argument("start_date", default=datetime.date.today().strftime('%Y-%m-%d'))
        # parser.add_argument("end_date", default=datetime.date.today().strftime('%Y-%m-%d'))
        parser.add_argument("start_date")
        parser.add_argument("end_date")
        parser.add_argument('call_direction', default=0)
        args = parser.parse_args()
        account_number = args['account_number']
        start_date = args['start_date']
        end_date = args['end_date']
        call_direction = args['call_direction']

        def get_active_accounts():
            account_list = []
            active_accounts = db.session.execute(const.SQL_ACTIVE_ACCOUNT)
            for acc in active_accounts:
                account_list.append(acc[0])
            return account_list

        def send_invoice_to_email():
            return None

        def generate_random_num(n):
            otp = ""
            for i in range(0, n):
                num = random.randint(1, 9)
                otp += str(num)
            return otp

        today = datetime.date.today()
        print(today)
        first = today.replace(day=1)
        last_month_year = first - datetime.timedelta(days=1)
        last_y = last_month_year.strftime("%Y")
        last_m = last_month_year.strftime("%m")
        # print(lastMonth.strftime("%Y-%m"))
        # print(last_m, last_y)
        # print(calendar.monthrange(int(last_y), int(last_m))[1])

        if not start_date or start_date == "":
            print("start date if")
            start_date = str(last_y) + '-' + str(last_m) + '-01'
            # start_date = datetime.datetime.strptime(start_date_str, '%Y-%m-%d')
        if not end_date or end_date == "":
            print("end date if")
            end_date = str(last_y) + '-' + str(last_m) + '-' + str(calendar.monthrange(int(last_y), int(last_m))[1])
            # end_date = datetime.datetime.strptime(end_date_str, '%Y-%m-%d')

        print(start_date + ' ' + end_date)
        # return jsonify(status=1, result='', messsage=str(start_date_str) + ' ' + str(end_date_str))

        connection = db.engine.raw_connection()
        call_report_data = {}
        active_accounts_list = []

        if account_number and account_number != "":
            active_accounts_list.append(account_number)
            # return jsonify(status=1, result='', messsage='Fetch single account')
        else:
            # Fetch all active accounts
            # active_accounts_list = get_active_accounts()
            active_accounts_list.append("400034")
            active_accounts_list.append("400015")
            active_accounts_list.append("400641")
            # return jsonify(status=1, result='', messsage='Fetch all active accounts')

        print(active_accounts_list)

        for accounts in active_accounts_list:
            print(accounts)
            # Procedure call to get call report
            try:
                cursor = connection.cursor()
                cursor.callproc('call_report', [accounts, start_date, end_date])
                call_details = cursor.fetchall()
                cursor.close()

                for (account_num, name, email, total_duration, inbound_duration, inbound_call_count, inbound_answered_count,
                     inbound_cost, outbound_duration, outbound_call_count, outbound_answered_count, outbound_cost) \
                        in call_details:
                    call_report_data = {
                        "account_number": int(account_num),
                        "account_name": str(name),
                        "email": str(email),
                        "inbound_total": int(inbound_call_count),
                        "inbound_answered": int(inbound_answered_count),
                        "inbound_duration": round(float(inbound_duration), 2),
                        "inbound_cost": round(float(inbound_cost), 2),
                        "outbound_total": int(outbound_call_count),
                        "outbound_answered": int(outbound_answered_count),
                        "outbound_duration": round(float(outbound_duration), 2),
                        "outbound_cost": round(float(outbound_cost), 2)
                    }
            except Exception as e:
                print(str(e))

            call_report_data['invoice_date'] = str(datetime.date.today().strftime('%Y-%m-%d'))
            call_report_data['invoice_period'] = str(start_date) + ' - ' + str(end_date)
            call_report_data['invoice_number'] = 'Q#' + str(datetime.date.today().strftime('%Y-%m-%d')) \
                                                 + '#' + str(generate_random_num(4))
            call_report_data['invoice_total'] = round(call_report_data['inbound_cost'] + call_report_data['outbound_cost'], 2)
            call_report_data['in_visibility'] = 'display:table;'
            call_report_data['out_visibility'] = 'display:table;'
            file_name = accounts + '_' + call_report_data['invoice_date'] + '_' + datetime.datetime.today().strftime('%H-%M-%S') + '.pdf'

            # if call_direction == 1:
            #     call_report_data['out_visibility'] = 'display:none;'
            # elif call_direction == 2:
            #     call_report_data['in_visibility'] = 'display:none;'

            if call_report_data['inbound_cost'] > 0 or call_report_data['outbound_cost'] > 0:

                # Get HTML Template string
                data = temp.TEMPLATE_INVOICE

                for key, value in call_report_data.items():
                    data = data.replace('{' + str(key) + '}', str(value))

                # return data

                # HTML to PDF conversion
                response = requests.post(
                    "http://sampleapi.quiits.com/api/v1/generate_pdf_from_html",
                    json={
                        "html": data,
                        "file_name": file_name
                    },
                    headers={
                        'Content-Type': 'application/json'
                    }
                )

                # print(response.json()['result'])

                # Email the invoice
                # send_invoice_to_email(call_report_data['email'])

            # return make_response(jsonify(status=1, result=''), 200)
            return jsonify(status=1, message='Success', result={"pdf_link": "https://api.quiits.com/templates/" + file_name})