"""Growaify Official Python SDK for AI Agents & Developers.
Install or import directly to interact with Growaify's Agent-Native Service Layer.
"""
import urllib.request
import json
import os

class GrowaifyClient:
    def __init__(self, base_url="https://growaify.com", partner_id=None, agent_id="autonomous_agent"):
        self.base_url = base_url.rstrip("/")
        self.partner_id = partner_id
        self.agent_id = agent_id

    def _req(self, endpoint, method="GET", data=None, headers=None, retries=3):
        url = f"{self.base_url}{endpoint}"
        h = headers or {}
        h["User-Agent"] = "Growaify-Python-SDK/1.0"
        h["Content-Type"] = "application/json"
        
        encoded_data = json.dumps(data).encode("utf-8") if data else None
        
        import time
        last_err = None
        for attempt in range(retries):
            try:
                req = urllib.request.Request(url, data=encoded_data, headers=h, method=method)
                with urllib.request.urlopen(req, timeout=20) as res:
                    return json.loads(res.read().decode("utf-8"))
            except urllib.error.HTTPError as e:
                last_err = e
                if e.code in [502, 503, 504] and attempt < retries - 1:
                    time.sleep(1.5)
                    continue
                raise e
            except Exception as e:
                last_err = e
                if attempt < retries - 1:
                    time.sleep(1.5)
                    continue
                raise e
        raise last_err

    def list_services(self):
        """Retrieve machine-readable services with explicit constraints and agent discounts."""
        return self._req("/api/v1/services")

    def discover(self, capability=None, billing=None, max_price=None):
        """Filter catalog capabilities with SLA, fulfillment time, and automation level."""
        qs = []
        if capability: qs.append(f"capability={urllib.request.quote(capability)}")
        if billing: qs.append(f"billing={urllib.request.quote(billing)}")
        if max_price: qs.append(f"max_price={max_price}")
        q_str = f"?{'&'.join(qs)}" if qs else ""
        return self._req(f"/api/v1/discover{q_str}")

    def negotiate_capabilities(self, required_capabilities):
        """Match list of required features (e.g. ['whatsapp', 'booking']) against catalog."""
        return self._req("/api/v1/capabilities/negotiate", method="POST", data={"required_capabilities": required_capabilities})

    def create_quote(self, service_id, quantity=1):
        """Generate a binding, deterministic quote with 20% partner commission attribution."""
        data = {
            "service_id": service_id,
            "quantity": quantity,
            "is_agent": True,
            "partner_id": self.partner_id
        }
        return self._req("/api/v1/quote", method="POST", data=data)

    def dry_run_order(self, service_id=None, quote_id=None):
        """Pre-flight check to validate requirements without financial commitment."""
        return self._req("/api/v1/orders/dry-run", method="POST", data={"service_id": service_id, "quote_id": quote_id})

    def create_order(self, service_id=None, quote_id=None, email="agent@autonomous.org", use_wallet=False, webhook_url=None, idempotency_key=None):
        """Submit idempotent commercial order to state machine."""
        headers = {}
        if idempotency_key:
            headers["Idempotency-Key"] = idempotency_key
        data = {
            "service_id": service_id,
            "quote_id": quote_id,
            "agent_id": self.agent_id,
            "partner_id": self.partner_id,
            "email": email,
            "use_wallet": use_wallet,
            "webhook_url": webhook_url
        }
        return self._req("/api/v1/orders", method="POST", data=data, headers=headers)

    def get_order(self, order_id):
        """Query state machine progress (0-100%) and provisioned digital deliverables."""
        return self._req(f"/api/v1/orders/{order_id}")

    def verify_deliverables(self, order_id):
        """Validate cryptographic SHA-256 provenance of completed order deliverables."""
        return self._req(f"/api/v1/orders/{order_id}/verification")

    def review_order(self, order_id, action="accept", reason=""):
        """Closed-loop acceptance or rejection (triggers re-fulfillment) of delivered service."""
        return self._req(f"/api/v1/orders/{order_id}/review", method="POST", data={"action": action, "reason": reason})

    def get_wallet(self):
        """Query agent's credit balance for autonomous instant settlements."""
        return self._req(f"/api/v1/wallets/{self.agent_id}")

    def procure(self, objective, budget=100.0, requirements=None, auto_purchase=True, email="agent@autonomous.org"):
        """Single-shot goal-based autonomous procurement endpoint."""
        data = {
            "objective": objective,
            "budget": budget,
            "currency": "USD",
            "requirements": requirements or [],
            "agent_id": self.agent_id,
            "auto_purchase": auto_purchase,
            "email": email
        }
        return self._req("/api/v1/procure", method="POST", data=data)

    def get_trust_status(self):
        """Retrieve live verifiable telemetry: uptime, success rate, and order proof."""
        return self._req("/api/v1/trust/status")