from django.conf import settings

import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'epay.settings')

app = Celery('epay')

app.config_from_object('django.conf:settings', namespace='CELERY')
# value of namespace means all the celery settings will start with "CELERY_"
#ref: https://stackoverflow.com/a/54839366/5305401
app.autodiscover_tasks()

from django.conf import settings

import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'epay.settings')

app = Celery('epay')
app.config_from_object('django.conf:settings', namespace='CELERY')

app.autodiscover_tasks()

from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app

__all__ = ['celery_app']

from celery import Celery
from celery.signals import task_failure
import requests
from django.conf import settings
import json
import time
from requests.auth import HTTPBasicAuth
from .models import Order, ClientApp, Session, ClientSession, Department
from epay.celery import app as celery_app


WAIT_IN_SECS_BEFORE_NEXT_CALL = 2


@celery_app.task(queue="epay")
def reconcile_all_missing_orders():
    sessions = Session.objects.filter(
       order=None
    )
    for session in sessions:
        reconcile_a_missing_session(session)

def reconcile_a_missing_session(session):
    transaction_response = fetch_order_details_from_bank(session.order_id)
    if _was_session_completed_successfully(transaction_response):
    # if _was_api_call_successfull(transaction_response) and _was_payment_transaction_successfull(transaction_response):
    #     # not storing order details again her because they are stored in
    #     # Order model already
    #     amount_to_be_paid = session.client_app.payment_amount
    #     paid_amount = transaction_response.get("amount")
    #     if paid_amount == amount_to_be_paid:
    #         session.reconciliation_details = {"kfupm_status": "paid"}
    #     else:
    #         session.reconciliation_details = {"kfupm_status": "partially_paid"}
    #     session.save()
    # elif transaction_response.get("error") or transaction_response.get("result") != "SUCCESS":
        session.reconciliation_details = transaction_response
        session.was_transaction_completed = True
        session.save()
        print(transaction_response)
        # continue
    else:
        session.was_transaction_completed = False
        session.save()
    try:
        order = Order.objects.create(
            session=session,
            all_details=transaction_response,
            status=transaction_response.get("result"),
        )
    except IntegrityError:
        order = Order.objects.get(session=session)
    time.sleep(
        WAIT_IN_SECS_BEFORE_NEXT_CALL
    )  # sleep before next API call to avoid making too many calls om short time

def _was_session_completed_successfully(transaction_response):
    return transaction_response.get("error", None) is None


def _was_api_call_successfull(transaction_response):
     return transaction_response.get("result") == "SUCCESS"

def _was_payment_transaction_successfull(transaction_response):
     return transaction_response.get("status") == "CAPTURED"

def fetch_order_details_from_bank(order_id):
    res = requests.get(
        "{}/{}/order/{}".format(
            settings.BANK_GATEWAY_API, settings.BANK_MERCHANT_ID, order_id
        ),
        auth=HTTPBasicAuth(settings.BANK_API_USERNAME, settings.BANK_API_PASSWORD),
    )
    result = json.loads(res.text)
    return result

send_feedback_email_task.apply_async(args=[
    self.cleaned_data["email"], self.cleaned_data["message"]
    ]
)

# celery
if is_env_var_set("CELERY_BROKER_ENDPOINT"):
    print("CELERY_BROKER_ENDPOINT is set")
    # Use 'rediss://' instead of 'redis://' for SSL connections
    # ** Note **
    #  CELERY_BROKER_URL env variable will be pickeup by the celery
    # use different name of env variable if not injecting complete endpoint
    CELERY_BROKER_URL = (
        # note the rediss:// instead of redis:// to use SSL
        "rediss://" +
        os.getenv("CELERY_BROKER_ENDPOINT") +
        ":6379" + "/0" +
        "?ssl_cert_reqs=required"
    )
    print("CELERY_BROKER_URL")
    print(CELERY_BROKER_URL)
else:
    CELERY_BROKER_URL = 'redis://localhost:6379/0'

export CELERY_BROKER_URL="xyz.redis.region.oci.oraclecloud.com"

def config_trace(service_name):
    APM_ENDPOINT_URL = os.environ.get("APM_ENDPOINT_URL")
    APM_PUBLIC_KEY = os.environ.get("APM_PUBLIC_KEY")
    apm_upload_endpoint_url = f"https://{APM_ENDPOINT_URL}/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey={APM_PUBLIC_KEY}"
    print("APM Endpoint URL:")
    print(apm_upload_endpoint_url)

    zipkin_exporter = ZipkinExporter(
        endpoint=apm_upload_endpoint_url,
        # Add other parameters as necessary
    )


    # Set up the tracer provider and processor
    trace.set_tracer_provider(
        TracerProvider(
            resource=Resource.create(
                {
                    "service.name": service_name,
                    "service.instance.id": "instance-replace-with-env-var",
                }
            )
        )
    )
    trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(zipkin_exporter))
    return trace
    # DjangoInstrumentor uses DJANGO_SETTINGS_MODULE to instrument the project.
    # Make sure the var is available before you call the DjangoInstrumentor.

@worker_process_init.connect(weak=False)
def init_celery_tracing(*args, **kwargs):
    print("********** worker_process_init **********")
    print("********** init_celery_tracing **********")
    trace = config_trace("worker-i-a")
    CeleryInstrumentor().instrument()
    tracer = trace.get_tracer(__name__)
    return tracer

celery -A invoicing_apis beat --loglevel=info & celery -A invoicing_apis worker --loglevel=info -P prefork

$ celery worker --app=worker.app

$ celery worker --app=worker.app --pool=threads

# start celery worker in solo mode
$ celery worker --app=worker.app --pool=solo