import requests
import json

from typing import List, Dict, Any
import itertools

def send_feishu_message(cluster_id, utc_day, json_data, bucket, file, webhook_url):

    message = {
        "msg_type": "interactive",
        "card": {
            "config": {
                "wide_screen_mode": True
            },
            "header": {
                "title": {
                    "tag": "plain_text",
                    "content": f"{cluster_id} ERROR/WARN 日志 - {utc_day}"
                },
                "template": "blue"  # 标题栏颜色，可选 blue/wathet/turquoise/green/yellow/orange/red
            },
            "elements": [
                {
                    "tag": "div",
                    "text": {
                        "tag": "plain_text",
                        "content": f"{json.dumps(json_data, indent=2, ensure_ascii=False)}\n\n"
                    }
                },
                {
                    "tag": "hr"  # 分割线
                },
                {
                    "tag": "note",
                    "elements": [
                        {
                            "tag": "plain_text",
                            "content": f"全天日志统计信息请下载 S3 文件, s3://{bucket}/{file}"
                        }
                    ]
                }
            ]
        }
    }

    try:
        headers = {'Content-Type': 'application/json'}
        response = requests.post(
            webhook_url,
            headers=headers,
            data=json.dumps(message, ensure_ascii=False).encode('utf-8'))

        result = response.json()
        if response.status_code == 200 and result.get("code") == 0:
            print("消息发送成功")
            return True
        else:
            print(f"消息发送失败，错误信息：{result.get('msg')}")
            return False
    except Exception as e:
        print(f"请求异常：{str(e)}")

    return False

def send_feishu_file(cluster_id, local_file):
    return

def generate_daily_statistic(data: List[Dict[str, Any]]) -> Dict[str, List[Dict]]:
    # def filter_fields(item: Dict) -> Dict:
    #     return {
    #         "level": item["level"],
    #         "component": item["component"],
    #         "position": item["position"],
    #         "total": item["total"],
    #         "log_content": item["log_content"],
    #     }

    # global_sorted = sorted(data, key=lambda x: x["total"], reverse=True)
    # global_top = [filter_fields(item) for item in global_sorted[:20]]

    # error = [
    #     item for item in data
    #     if item["level"] in ("ERROR")
    # ]
    # error_sorted = sorted(error, key=lambda x: x["total"], reverse=True)
    # error_top = [filter_fields(item) for item in error_sorted[:10]]

    # warn = [
    #     item for item in data
    #     if item["level"] in ("WARN")
    # ]
    # warn_sorted = sorted(warn, key=lambda x: x["total"], reverse=True)
    # warn_top = [filter_fields(item) for item in warn_sorted[:10]]

    new_error = [
        item for item in data
        if item["level"] in ("ERROR") and "tags" in item and any("new" in tags.lower() for tags in item["tags"])
    ]
    # ner_error_sorted = sorted(new_error, key=lambda x: x["total"], reverse=True)
    # new_error_top_10 = [filter_fields(item) for item in ner_error_sorted[:10]]

    new_warn = [
        item for item in data
        if item["level"] in ("WARN") and "tags" in item and any("new" in tags.lower() for tags in item["tags"])
    ]

    # ner_warn_sorted = sorted(new_warn, key=lambda x: x["total"], reverse=True)
    # new_warn_top_10 = [filter_fields(item) for item in ner_warn_sorted[:10]]

    level_component_statistic = {}
    for item in data:
        level = item['level']
        component = item['component']
        total = item['total']
        if level not in level_component_statistic:
            level_component_statistic[level] = {}
        level_component_statistic[level][component] = level_component_statistic[level].get(component, 0) + total

    result = {
        "all_logs_statistics": level_component_statistic,
        "new_logs_statistics": {
            "new_error": sum(itertools.accumulate(
                (item["total"] for item in new_error),
                initial=0
            )),
            "new_warn": sum(itertools.accumulate(
                (item["total"] for item in new_warn),
                initial=0
            )),
        },
        # "new_error_log_top": new_error_top_10,
        # "new_warn_log_top": new_warn_top_10,
    }


    return result