import logging
from typing import Any, Dict, Optional

import requests


logger = logging.getLogger(__name__)


class LeadSquaredService:
    """Python port of LeadSquared integration service used in tatsat2dev/leadsquared."""

    def __init__(
        self,
        access_key: str,
        secret_key: str,
        api_host: Optional[str] = None,
        timeout: int = 30,
    ):
        self.access_key = (access_key or "").strip()
        self.secret_key = (secret_key or "").strip()
        self.api_host = (api_host or "https://api-in21.leadsquared.com/v2/").rstrip("/")
        self.timeout = int(timeout)

    def _auth_params(self) -> Dict[str, str]:
        return {
            "accessKey": self.access_key,
            "secretKey": self.secret_key,
        }

    def _request(
        self,
        method: str,
        endpoint: str,
        query_params: Optional[Dict[str, Any]] = None,
        payload: Optional[Dict[str, Any]] = None,
    ) -> Dict[str, Any]:
        if not self.access_key or not self.secret_key:
            return {
                "success": False,
                "message": "LeadSquared credentials are missing",
                "data": None,
            }

        url = f"{self.api_host}/{endpoint.lstrip('/')}"
        params = self._auth_params()
        if query_params:
            params.update(query_params)

        try:
            response = requests.request(
                method=method.upper(),
                url=url,
                params=params,
                json=payload,
                timeout=self.timeout,
            )

            if response.ok:
                parsed: Any
                try:
                    parsed = response.json()
                except Exception:
                    parsed = {"raw": response.text}
                return {
                    "success": True,
                    "message": "Request successful",
                    "data": parsed,
                }

            logger.error(
                "LeadSquared API request failed: %s %s status=%s body=%s",
                method,
                endpoint,
                response.status_code,
                response.text,
            )
            return {
                "success": False,
                "message": f"LeadSquared API error ({response.status_code}): {response.text}",
                "data": None,
            }
        except Exception as exc:
            logger.error("LeadSquared request exception: %s", exc, exc_info=True)
            return {
                "success": False,
                "message": f"Exception: {str(exc)}",
                "data": None,
            }

    def test_connection(self) -> Dict[str, Any]:
        result = self.search_leads(
            {
                "Paging": {
                    "Offset": 0,
                    "RowCount": 1,
                }
            }
        )
        if result.get("success"):
            return {
                "success": True,
                "message": "LeadSquared connection successful",
                "credentials": {
                    "access_key": f"{self.access_key[:10]}..." if self.access_key else "",
                    "api_host": self.api_host,
                },
            }
        return {
            "success": False,
            "message": f"LeadSquared connection failed: {result.get('message')}",
        }

    def search_leads(self, search_params: Dict[str, Any]) -> Dict[str, Any]:
        return self._request(
            method="POST",
            endpoint="LeadManagement.svc/Leads.Get",
            payload=search_params or {},
        )

    def get_lead(self, lead_id: str) -> Dict[str, Any]:
        return self._request(
            method="GET",
            endpoint="LeadManagement.svc/Leads.GetById",
            query_params={"id": str(lead_id)},
        )

    def create_lead(self, lead_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request(
            method="POST",
            endpoint="LeadManagement.svc/Lead.Create",
            payload=lead_data or {},
        )

    def update_lead(self, lead_id: str, lead_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request(
            method="POST",
            endpoint="LeadManagement.svc/Lead.Update",
            query_params={"leadId": str(lead_id)},
            payload=lead_data or {},
        )

    def delete_lead(self, lead_id: str) -> Dict[str, Any]:
        # LeadSquared supports delete endpoint in v2 for lead records.
        return self._request(
            method="POST",
            endpoint="LeadManagement.svc/Lead.Delete",
            query_params={"leadId": str(lead_id)},
            payload={},
        )