import os
import json
from itertools import chain

import lark_oapi as lark

from flask import Flask
from dotenv import load_dotenv
from lark_oapi.adapter.flask import *
from lark_oapi.api.im.v1 import *
from lark_oapi.api.bitable.v1 import *
import lark_oapi as lark
from lark_oapi.api.drive.v1 import *


def update_record(client, bitable_token, table_id, record_id, data):
    # 构造请求对象
    request: UpdateAppTableRecordRequest = (
        UpdateAppTableRecordRequest.builder()
        .app_token(bitable_token)
        .table_id(table_id)
        .record_id(record_id)
        .request_body(AppTableRecord.builder().fields(data).build())
        .build()
    )

    # 发起请求
    option = (
        lark.RequestOption.builder()
        .user_access_token("u-fEsiJAcUZaOFrBI0iYa6N61l4zvBghNxr200l1K82GvD")
        .build()
    )
    response: UpdateAppTableRecordResponse = client.bitable.v1.app_table_record.update(
        request, option
    )

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.bitable.v1.app_table_record.update failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))


def add_record(client, bitable_token, table_id, data):
    # 构造请求对象
    request: CreateAppTableRecordRequest = (
        CreateAppTableRecordRequest.builder()
        .app_token(bitable_token)
        .table_id(table_id)
        .request_body(AppTableRecord.builder().fields(data).build())
        .build()
    )

    # 发起请求
    response: CreateAppTableRecordResponse = client.bitable.v1.app_table_record.create(
        request
    )

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.bitable.v1.app_table_record.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))

    return response.data.record.record_id


def get_message_resource(client, message_id, file_key, file_type, save_dir):
    request: GetMessageResourceRequest = (
        GetMessageResourceRequest.builder()
        .message_id(message_id)
        .file_key(file_key)
        .type(file_type)
        .build()
    )
    response: GetMessageResourceResponse = client.im.v1.message_resource.get(request)

    if not response.success():
        lark.logger.error(
            f"client.im.v1.message_resource.get failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果

    file_path = os.path.join(save_dir, file_key + ".png")
    with open(file_path, "wb") as f:
        f.write(response.file.read())

    return file_path


def upload_media(client, file_path, parent_type, parent_node):
    # 构造请求对象
    _, filename = os.path.split(file_path)
    file_size = os.path.getsize(file_path)

    with open(file_path, "rb") as f:
        request: UploadAllMediaRequest = (
            UploadAllMediaRequest.builder()
            .request_body(
                UploadAllMediaRequestBody.builder()
                .file_name(filename)
                .parent_type(parent_type)
                .parent_node(parent_node)
                .size(file_size)
                .file(f)
                .build()
            )
            .build()
        )

        # 发起请求
        option = (
            lark.RequestOption.builder()
            .user_access_token("u-dF0r5rD5BcUFhORI38zmlk1l61TBghPzry00gl.82Haz")
            .build()
        )
        response: UploadAllMediaResponse = client.drive.v1.media.upload_all(
            request, option
        )

        # # 处理失败返回
        # if not response.success():
        #     lark.logger.error(
        #         f"client.drive.v1.media.upload_all failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        #     )
        #     return

        # 处理业务结果
        lark.logger.info(lark.JSON.marshal(response.data, indent=4))

        return response.data.file_token


def send_group_message(client, message_id, content):
    # 构造请求对象

    request: ReplyMessageRequest = (
        ReplyMessageRequest.builder()
        .message_id(message_id)
        .request_body(
            ReplyMessageRequestBody.builder()
            .content(content=content)
            .msg_type("text")
            .reply_in_thread(True)
            .build()
        )
        .build()
    )

    # 发起请求
    response: ReplyMessageResponse = client.im.v1.message.reply(request)

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.im.v1.message.reply failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))


def send_message(client, receive_id, content):
    # 构造请求对象
    request: CreateMessageRequest = (
        CreateMessageRequest.builder()
        .receive_id_type("open_id")
        .request_body(
            CreateMessageRequestBody.builder()
            .receive_id(receive_id)
            .msg_type("text")
            .content(content)
            .build()
        )
        .build()
    )

    # 发起请求
    response: CreateMessageResponse = client.im.v1.message.create(request)

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.im.v1.message.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))