#!/usr/bin/env python3
"""Automate Google Takeout backup verification."""

import os
import json
import hashlib
import zipfile
from datetime import datetime
from pathlib import Path

class TakeoutBackupManager:
    def __init__(self, backup_dir: str = "~/Google-Backups"):
        self.backup_dir = Path(backup_dir).expanduser()
        self.backup_dir.mkdir(parents=True, exist_ok=True)
        self.manifest_file = self.backup_dir / "manifest.json"
        self.load_manifest()

    def load_manifest(self):
        """Load or create backup manifest."""
        if self.manifest_file.exists():
            with open(self.manifest_file, 'r') as f:
                self.manifest = json.load(f)
        else:
            self.manifest = {
                "backups": [],
                "last_verified": None
            }

    def save_manifest(self):
        """Save manifest to disk."""
        with open(self.manifest_file, 'w') as f:
            json.dump(self.manifest, f, indent=2)

    def verify_backup(self, backup_file: str) -> dict:
        """Verify integrity of Takeout backup."""
        backup_path = self.backup_dir / backup_file

        if not backup_path.exists():
            return {
                "status": "missing",
                "file": backup_file,
                "error": "Backup file not found"
            }

        # Calculate file hash
        hash_sha256 = hashlib.sha256()
        with open(backup_path, "rb") as f:
            for chunk in iter(lambda: f.read(4096), b""):
                hash_sha256.update(chunk)

        file_hash = hash_sha256.hexdigest()

        # Check ZIP integrity
        try:
            with zipfile.ZipFile(backup_path, 'r') as zip_file:
                test_result = zip_file.testzip()
                zip_valid = test_result is None
        except Exception as e:
            zip_valid = False

        # Check for expected folders
        expected_services = ['Gmail', 'Drive', 'Photos', 'Calendar', 'Contacts']
        contained_services = []

        try:
            with zipfile.ZipFile(backup_path, 'r') as zip_file:
                namelist = zip_file.namelist()
                for service in expected_services:
                    if any(service.lower() in name.lower() for name in namelist):
                        contained_services.append(service)
        except Exception:
            pass

        result = {
            "status": "verified" if zip_valid else "corrupted",
            "file": backup_file,
            "file_hash": file_hash,
            "zip_valid": zip_valid,
            "services_included": contained_services,
            "services_expected": expected_services,
            "completeness": len(contained_services) / len(expected_services),
            "verified_at": datetime.now().isoformat()
        }

        return result

    def verify_all_backups(self) -> dict:
        """Verify all backups in directory."""
        results = {
            "total_backups": 0,
            "valid_backups": 0,
            "corrupted_backups": 0,
            "backups": [],
            "verification_time": datetime.now().isoformat()
        }

        for backup_file in self.backup_dir.glob("*.zip"):
            result = self.verify_backup(backup_file.name)
            results["backups"].append(result)
            results["total_backups"] += 1

            if result["status"] == "verified":
                results["valid_backups"] += 1
            else:
                results["corrupted_backups"] += 1

        # Update manifest
        self.manifest["last_verified"] = datetime.now().isoformat()
        self.manifest["verification_results"] = results
        self.save_manifest()

        return results

    def generate_report(self) -> str:
        """Generate human-readable backup verification report."""
        results = self.verify_all_backups()

        report = f"""
=== Google Takeout Backup Verification Report ===
Generated - {results['verification_time']}

- Total backups found: {results['total_backups']}
- Valid backups: {results['valid_backups']}
- Corrupted backups: {results['corrupted_backups']}

Details:
"""

        for backup in results['backups']:
            status_icon = "" if backup['status'] == 'verified' else ""
            report += f"\n{status_icon} {backup['file']}\n"
            report += f"   Status: {backup['status']}\n"
            report += f"   Services: {', '.join(backup['services_included'])}\n"
            if 'file_hash' in backup:
                report += f"   Hash - {backup['file_hash'][:16]}...\n"

        return report

Usage
manager = TakeoutBackupManager()
print(manager.generate_report())