#!/usr/bin/env python3
"""Pyvorin Edge Generate CLI.

Generate Edge configs, pipeline boilerplate, sensor definitions,
privacy policies, and Dockerfiles.
"""

import argparse
import json
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, List, Optional


def _write(path: Optional[str], content: str) -> None:
    if path:
        p = Path(path)
        p.write_text(content, encoding="utf-8")
        print(f"Generated {p}")
    else:
        print(content)


def cmd_config(args: argparse.Namespace) -> int:
    toml = """# Pyvorin Edge Configuration Template
# Generated by pyv-edge-generate

[edge]
name = "edge-node-01"
version = "1.0.0"
region = "us-east-1"

[ingest]
batch_size = 1000
flush_interval_ms = 5000

[privacy]
enable_filter = true
max_value = 100
redaction_mask = "****"

[sync]
endpoint = "https://api.pyvorin.com/v1/ingest"
retry_count = 3
timeout_seconds = 30

[telemetry]
enabled = true
sample_rate = 0.1
"""
    _write(args.output, toml)
    return 0


def cmd_pipeline(args: argparse.Namespace) -> int:
    code = """# Pyvorin Edge Pipeline Template
# Generated by pyv-edge-generate

from typing import List, Dict, Any


def ingest(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    \"\"\"Ingest raw sensor records.\"\"\"
    return data


def transform(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    \"\"\"Apply transformations and privacy filters.\"\"\"
    out = []
    for r in records:
        val = r.get("value", 0)
        if val > 100:
            val = 100
        out.append({"id": r.get("id"), "value": val})
    return out


def aggregate(records: List[Dict[str, Any]]) -> Dict[str, Any]:
    \"\"\"Compute aggregates.\"\"\"
    total = sum(r["value"] for r in records)
    return {"count": len(records), "total": total}


def pipeline(data: List[Dict[str, Any]]) -> Dict[str, Any]:
    \"\"\"Run full pipeline: ingest -> transform -> aggregate.\"\"\"
    records = ingest(data)
    records = transform(records)
    return aggregate(records)


if __name__ == "__main__":
    sample = [{"id": i, "value": i * 10} for i in range(10)]
    print(pipeline(sample))
"""
    _write(args.output, code)
    return 0


def cmd_sensors(args: argparse.Namespace) -> int:
    count = max(1, args.count)
    sensors: List[Dict[str, Any]] = []
    for i in range(count):
        sensors.append(
            {
                "id": f"sensor-{i:03d}",
                "type": "temperature",
                "location": f"zone-{chr(65 + (i % 26))}",
                "interval_ms": 1000,
            }
        )
    payload = json.dumps(sensors, indent=2)
    _write(args.output, payload)
    return 0


def cmd_policy(args: argparse.Namespace) -> int:
    policy = {
        "version": "1.0.0",
        "created": datetime.now(timezone.utc).isoformat(),
        "retention_days": 30,
        "fields": [
            {"name": "user_id", "action": "hash", "algorithm": "sha256"},
            {"name": "email", "action": "mask", "pattern": "****"},
            {"name": "ssn", "action": "redact"},
        ],
        "auditing": {
            "enabled": True,
            "log_level": "info",
        },
    }
    payload = json.dumps(policy, indent=2)
    _write(args.output, payload)
    return 0


def cmd_docker(args: argparse.Namespace) -> int:
    dockerfile = """# Pyvorin Edge Deployment Dockerfile
# Generated by pyv-edge-generate

FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Health check
HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \\
  CMD python -c "print('ok')" || exit 1

# Run edge pipeline
CMD ["python", "-m", "edge.pipeline"]
"""
    _write(args.output, dockerfile)
    return 0


def main(argv: Optional[List[str]] = None) -> int:
    parser = argparse.ArgumentParser(
        prog="pyv-edge-generate",
        description="Pyvorin Edge Generate CLI",
    )
    sub = parser.add_subparsers(dest="command", required=True)

    p_config = sub.add_parser("config", help="Generate a config.toml template")
    p_config.add_argument("--output", required=True, help="Output file path")
    p_config.set_defaults(func=cmd_config)

    p_pipeline = sub.add_parser("pipeline", help="Generate a pipeline.py template")
    p_pipeline.add_argument("--output", required=True, help="Output file path")
    p_pipeline.set_defaults(func=cmd_pipeline)

    p_sensors = sub.add_parser("sensors", help="Generate sensors.json")
    p_sensors.add_argument("--count", type=int, default=5, help="Number of sensors")
    p_sensors.add_argument("--output", required=True, help="Output file path")
    p_sensors.set_defaults(func=cmd_sensors)

    p_policy = sub.add_parser("policy", help="Generate a privacy policy JSON")
    p_policy.add_argument("--output", required=True, help="Output file path")
    p_policy.set_defaults(func=cmd_policy)

    p_docker = sub.add_parser("docker", help="Generate a Dockerfile")
    p_docker.add_argument("--output", required=True, help="Output file path")
    p_docker.set_defaults(func=cmd_docker)

    args = parser.parse_args(argv)
    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())
