import os
import json
import time

import lark_oapi as lark
from celery import Celery
from celery import Task


from flask import Flask
from dotenv import load_dotenv
from itertools import chain
from lark_oapi.adapter.flask import *
from lark_oapi.api.im.v1 import *
from lark_oapi.api.bitable.v1 import *

from app.task import *
from app.utils import *
from app.task import *

load_dotenv()


app_id = os.environ["APP_ID"]
app_secret = os.environ["APP_SECRET"]

encrypt_key = os.environ["ENCRYPT_KEY"]
verification_token = os.environ["VERIFICATION_TOKEN"]

bitable_token = os.environ["BITABLE_TOKEN"]
table_id = os.environ["TABLE_ID"]

bitable_token = "IRggb4I0MaRffTsJ7qkcw1wxnBg"
table_id = "tbl5J3sXBNIyNvJ8"

broker_url = os.environ["BROKER_URL"]
result_backend = os.environ["RESULT_BACKEND"]


# 创建client
client = lark.Client.builder().app_id(app_id).app_secret(app_secret).build()

current_dir = os.path.dirname(os.path.abspath(__file__))
cache_dir = os.path.join(current_dir, "cache")

if not os.path.exists(cache_dir):
    os.makedirs(cache_dir)


def do_p2_im_message_receive_v1(data: P2ImMessageReceiveV1) -> None:
    # print(client, bitable_token, table_id, cache_dir, data)
    process_message_callback.delay(
        app_id, app_secret, bitable_token, table_id, cache_dir, data
    )
    print(lark.JSON.marshal(data))


def do_customized_event(data: lark.CustomizedEvent) -> None:
    print(lark.JSON.marshal(data))


handler = (
    lark.EventDispatcherHandler.builder(
        encrypt_key, verification_token, lark.LogLevel.DEBUG
    )
    .register_p2_im_message_receive_v1(do_p2_im_message_receive_v1)
    .register_p1_customized_event("message", do_customized_event)
    .build()
)


def create_app() -> Flask:
    app = Flask(__name__)

    app.config.from_mapping(
        CELERY=dict(
            broker_url=broker_url,
            result_backend=result_backend,
            task_ignore_result=True,
            broker_connection_retry_on_startup=True,
        ),
    )
    app.config.from_prefixed_env()
    celery_init_app(app)

    @app.route("/event", methods=["POST"])
    def event():
        print("receive event: ", time.time())
        resp = handler.do(parse_req())
        return parse_resp(resp)

    @app.route("/test", methods=["GET"])
    def test():
        add.delay(1, 2)
        return {"test": "ok"}

    return app


def celery_init_app(app: Flask) -> Celery:
    class FlaskTask(Task):
        def __call__(self, *args: object, **kwargs: object) -> object:
            with app.app_context():
                return self.run(*args, **kwargs)

    celery_app = Celery(app.name, task_cls=FlaskTask)
    celery_app.config_from_object(app.config["CELERY"])
    celery_app.set_default()
    app.extensions["celery"] = celery_app
    return celery_app