# -*- coding: utf-8 -*-
import json
from typing import Dict, Optional

import requests
from loguru import logger


class DifyClient:
    """Dify completion/workflow 通用调用客户端"""

    def __init__(self, api_config: Optional[Dict] = None):
        api_config = api_config or {}
        self.LOG = logger
        self.enabled = bool(api_config.get("enable", api_config.get("enabled", False)))
        self.base_url = (api_config.get("base_url") or "").rstrip("/")
        self.api_key = api_config.get("api_key", "")
        self.timeout = int(api_config.get("request_timeout", 60))
        self.mode = str(api_config.get("mode", "completion")).strip().lower()
        default_endpoint = "workflows/run" if self.mode == "workflow" else "completion-messages"
        self.endpoint = str(api_config.get("endpoint", default_endpoint)).lstrip("/")
        self.workflow_output_key = str(api_config.get("workflow_output_key", "text")).strip()

    def is_available(self) -> bool:
        return self.enabled and bool(self.base_url and self.api_key)

    def run(self, prompt: str, user: str, inputs: Optional[Dict] = None,
            tag: str = "") -> Optional[Dict]:
        if not self.is_available():
            return None

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json",
        }
        payload_inputs = dict(inputs or {})
        if self.mode == "completion":
            payload_inputs.setdefault("query", prompt)
        elif prompt and "query" not in payload_inputs:
            payload_inputs["query"] = prompt

        payload = {
            "inputs": payload_inputs,
            "response_mode": "blocking",
            "user": user,
        }
        url = f"{self.base_url}/{self.endpoint}"
        try:
            self.LOG.info(f"[成员交互摘要][Dify] 发起请求: mode={self.mode}, endpoint={self.endpoint}, tag={tag}")
            response = requests.post(url, headers=headers, json=payload, timeout=self.timeout)
            response.raise_for_status()
            data = response.json()
            parsed = self._parse_response(data)
            if parsed is not None:
                return parsed
            self.LOG.warning(
                f"[成员交互摘要][Dify] 响应内容为空: mode={self.mode}, tag={tag}, "
                f"response_preview={(response.text or '')[:300]}"
            )
            return None
        except Exception as e:
            self.LOG.warning(f"[成员交互摘要][Dify] 请求失败: mode={self.mode}, tag={tag}, error={e}")
            return None

    def _parse_response(self, data: Dict) -> Optional[Dict]:
        if self.mode == "workflow":
            return self._parse_workflow_response(data)
        answer = data.get("answer", "")
        usage = (data.get("metadata") or {}).get("usage", {}) or {}
        return {
            "text": str(answer or "").strip(),
            "usage": usage,
            "raw": data,
        }

    def _parse_workflow_response(self, data: Dict) -> Optional[Dict]:
        payload = (data or {}).get("data", {}) or {}
        outputs = payload.get("outputs", {}) or {}
        text = ""

        if self.workflow_output_key and outputs.get(self.workflow_output_key) is not None:
            value = outputs.get(self.workflow_output_key)
            text = self._stringify_output(value)
        elif outputs.get("text") is not None:
            text = self._stringify_output(outputs.get("text"))
        elif outputs.get("answer") is not None:
            text = self._stringify_output(outputs.get("answer"))
        elif outputs.get("result_json") is not None:
            text = self._stringify_output(outputs.get("result_json"))
        elif outputs.get("result") is not None:
            text = self._stringify_output(outputs.get("result"))
        else:
            for value in outputs.values():
                text = self._stringify_output(value)
                if text:
                    break

        usage = {
            "total_tokens": payload.get("total_tokens"),
            "latency": payload.get("elapsed_time"),
        }
        return {
            "text": str(text or "").strip(),
            "usage": usage,
            "raw": data,
        }

    @staticmethod
    def _stringify_output(value) -> str:
        if value is None:
            return ""
        if isinstance(value, str):
            return value.strip()
        if isinstance(value, (dict, list)):
            return json.dumps(value, ensure_ascii=False)
        return str(value).strip()