import textwrap
from typing import Optional
import httpx
import time
import asyncio
from django.db import models
from your_app.models import HostName
from your_framework import Tool, Parameter


async def get_thanos_url_for_hostname(hostname_hint: str) -> str:
    '''Resolve any hostname hint → correct Thanos URL using async Django ORM.'''
    host_obj = await HostName.objects.filter(
        models.Q(hostname__iexact=hostname_hint) |
        models.Q(fqdn__iexact=hostname_hint)
    ).select_related('server__environment').afirst()

    if not host_obj:
        raise ValueError(f"Host '{hostname_hint}' not found in inventory")

    if not host_obj.server or not host_obj.server.environment:
        raise ValueError(f"Host '{hostname_hint}' has no server or environment configured")

    url = host_obj.server.environment.thanos_query_server
    if not url:
        raise ValueError(f"Environment for '{hostname_hint}' has no Thanos URL")

    return url.rstrip('/')


class ListPrometheusInstances(Tool):
    description = textwrap.dedent('''
        List currently scraped instances in the correct environment.
        Handles:
        • node_exporter → instance = http://primary-fqdn:9100
        • cassandra_exporter → instance = cass-node-name:8080 + cluster/rack labels
    ''')

    hostname_hint = Parameter(
        type='string',
        description='Any hostname/FQDN you know (e.g. db01, cass-stg-07.example.com)',
        required=True,
    )
    job = Parameter(
        type='string',
        description="Optional filter: 'node_exporter' or 'cassandra_exporter'",
        required=False,
    )

    async def run(self, conversation, hostname_hint: str, job: Optional[str] = None) -> str:
        try:
            thanos_base = await get_thanos_url_for_hostname(hostname_hint)
        except Exception as e:
            return f"[list_prometheus_instances] ERROR: {e}"

        env_name = 'PRODUCTION' if 'prod' in thanos_base.lower() else 'STAGING'

        # Build correct match expression
        if job == 'node_exporter':
            match_query = 'up{job="node_exporter"}'
        elif job == 'cassandra_exporter':
            match_query = 'up{job="cassandra_exporter"}'
        else:
            match_query = 'up'

        async with httpx.AsyncClient(timeout=20.0) as client:
            try:
                resp = await client.get(
                    f"{thanos_base}/api/v1/query",
                    params={'query': match_query},
                    timeout=20,
                )
                resp.raise_for_status()
                results = resp.json()['data']['result']
            except Exception as e:
                return f"[list_prometheus_instances] {env_name} — Query failed: {e}"

        if not results:
            return f"[list_prometheus_instances] {env_name} — No instances found."

        lines = [
            f"[list_prometheus_instances] {env_name} (resolved via {hostname_hint})",
            f"    Found {len(results)} instances\n"
        ]

        for r in sorted(results, key=lambda x: x['metric'].get('instance', '')):
            m = r['metric']
            instance_raw = m.get('instance', '?')
            job_name = m.get('job', 'unknown')

            if job_name == 'node_exporter':
                # http://host.prod.example.com:9100 → host.prod.example.com
                clean = instance_raw.replace('http://', '').split(':')[0]
                display = f"{clean:<48}  node_exporter"
            else:
                # Cassandra exporter
                cass_node = instance_raw.split(':')[0]
                cluster = m.get('cluster', '?')
                rack = m.get('rack', '?')
                display = f"{cass_node:<30}  cassandra_exporter  cluster={cluster} rack={rack}"

            lines.append(f"    {display}")

        return '\n'.join(lines)


class QueryPrometheus(Tool):
    description = textwrap.dedent('''
        Run any PromQL query in the correct environment.
        Works perfectly with both:
        • instance="http://primary-fqdn:9100" (node_exporter)
        • instance="cassandra-node:8080" + cluster/rack (cassandra_exporter)
    ''')

    hostname_hint = Parameter(
        type='string',
        description='Any known hostname in the target environment',
        required=True,
    )
    query = Parameter(
        type='string',
        description='Exact PromQL query — use instance labels from list_prometheus_instances',
        required=True,
    )
    time_range_minutes = Parameter(
        type='integer',
        description='For range queries: look back N minutes',
        required=False,
    )

    async def run(self, conversation, hostname_hint: str, query: str,
                  time_range_minutes: Optional[int] = None) -> str:
        try:
            thanos_base = await get_thanos_url_for_hostname(hostname_hint)
        except Exception as e:
            return f"[query_prometheus] ERROR: {e}"

        env_name = 'PRODUCTION' if 'prod' in thanos_base.lower() else 'STAGING'

        async with httpx.AsyncClient(timeout=45.0) as client:
            try:
                if time_range_minutes and time_range_minutes > 0:
                    end = int(time.time())
                    start = end - time_range_minutes * 60
                    resp = await client.get(
                        f"{thanos_base}/api/v1/query_range",
                        params={
                            'query': query,
                            'start': start,
                            'end': end,
                            'step': '60s',
                        },
                    )
                else:
                    resp = await client.get(
                        f"{thanos_base}/api/v1/query",
                        params={'query': query},
                    )
                resp.raise_for_status()
                data = resp.json()['data']
            except Exception as e:
                return f"[query_prometheus] {env_name} — Request failed: {e}"

        if not data.get('result'):
            return f"[query_prometheus] {env_name} — No results\nQuery: {query}"

        lines = [
            f"[query_prometheus] {env_name} (via {hostname_hint})",
            f"Query: {query}",
        ]
        if time_range_minutes:
            lines.append(f"Range: last {time_range_minutes} min")

        for series in data['result'][:50]:
            m = series['metric']
            inst_raw = m.get('instance', m.get('job', 'unknown'))
            job_name = m.get('job', 'unknown')

            if job_name == 'node_exporter':
                inst_display = inst_raw.replace('http://', '').split(':')[0]
                extra = ''
            else:
                inst_display = inst_raw.split(':')[0]
                cluster = m.get('cluster', '?')
                rack = m.get('rack', '?')
                extra = f"  cluster={cluster} rack={rack}"

            labels = ' '.join(
                f"{k}={v}"
                for k, v in m.items()
                if k not in {'__name__', 'instance', 'job', 'cluster', 'rack'}
            )

            lines.append(f"\n  • {inst_display}{extra}  {labels}".strip())

            if 'value' in series:
                lines.append(f"    → {series['value'][1]}")
            else:
                for ts, val in series['values'][-5:]:
                    try:
                        tm_resp = await client.get(
                            f"{thanos_base}/api/v1/format_time",
                            params={'time': ts},
                            timeout=5,
                        )
                        tm = tm_resp.text.strip() if tm_resp.ok else '?'
                    except Exception:
                        tm = '?'
                    lines.append(f"    [{tm}] {val}")

        if len(data['result']) > 50:
            lines.append(f"\n... (truncated, {len(data['result'])} total series)")

        return '\n'.join(lines)

class ListPrometheusInstances(Tool):
    description = textwrap.dedent('''
        List currently scraped instances in the correct environment.
        Your setup:
        • job="node"       → node_exporter (instance = primary-hostname:9100)
        • job="nodetool"   → centralized custom exporter (instance is useless, use hostname= label instead)
    ''')

    hostname_hint = Parameter(
        type='string',
        description='Any hostname you know in the target environment (e.g. web01, cass07, db-stg-03)',
        required=True,
    )
    job = Parameter(
        type='string',
        description="Filter by job: 'node' or 'nodetool'",
        required=False,
    )

    async def run(self, conversation, hostname_hint: str, job: Optional[str] = None) -> str:
        try:
            thanos_base = await get_thanos_url_for_hostname(hostname_hint)
        except Exception as e:
            return f"[list_prometheus_instances] ERROR: {e}"

        env_name = 'PRODUCTION' if 'prod' in thanos_base.lower() else 'STAGING'

        # Build correct query for each job
        if job == 'node':
            promql = 'up{job="node"}'
        elif job == 'nodetool':
            promql = 'up{job="nodetool"}'
        else:
            promql = 'up{job=~"node|nodetool"}'

        async with httpx.AsyncClient(timeout=20.0) as client:
            try:
                resp = await client.get(
                    f"{thanos_base}/api/v1/query",
                    params={'query': promql},
                    timeout=20,
                )
                resp.raise_for_status()
                results = resp.json()['data']['result']
            except Exception as e:
                return f"[list_prometheus_instances] {env_name} — Query failed: {e}"

        if not results:
            return f"[list_prometheus_instances] {env_name} — No instances found."

        lines = [
            f"[list_prometheus_instances] {env_name} (via {hostname_hint})",
            f"    Found {len(results)} instances\n"
        ]

        for r in sorted(results, key=lambda x: x['metric'].get('instance', '') or x['metric'].get('hostname', '')):
            m = r['metric']
            job_name = m.get('job', 'unknown')

            if job_name == 'node':
                instance = m.get('instance', '?')
                clean_host = instance.split(':')[0]  # removes :9100
                display = f"{clean_host:<45}  node_exporter"
            else:  # job="nodetool"
                hostname_label = m.get('hostname', '?')
                useless_instance = m.get('instance', '?')
                display = f"{hostname_label:<30}  nodetool_exporter  (instance={useless_instance} → ignore)"

            lines.append(f"    {display}")

        return '\n'.join(lines)