#!/usr/bin/env python3
"""InfoKeyword Firebase 프로젝트 분리 자동화 스크립트
새 Firebase 프로젝트 생성 → 서비스 설정 → 규칙 배포 → 인덱스 생성 → 환경변수 교체
"""

import json
import os
import subprocess
import sys
import time
import urllib.request
import urllib.error

# Configuration
NEW_PROJECT_ID = "infokeyword-j2h"
NEW_PROJECT_NAME = "InfoKeyword"
OLD_PROJECT_ID = "insuwiki-j2h"
REGION = "asia-northeast3"
INFOKEYWORD_DIR = "/home/jay/projects/InfoKeyword"
INSUWIKI_DIR = "/home/jay/projects/insuwiki"
SA_KEY_FILE = "/home/jay/.config/gcloud/service-accounts/insuwiki-j2h-fa603f4f75f5.json"

def get_token():
    """Get access token from gcloud"""
    result = subprocess.run(
        ["gcloud", "auth", "print-access-token"],
        capture_output=True, text=True
    )
    return result.stdout.strip()

def api_call(method, url, data=None, token=None, quota_project=None):
    """Make authenticated API call"""
    if token is None:
        token = get_token()

    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }
    if quota_project:
        headers["X-Goog-User-Project"] = quota_project

    body = json.dumps(data).encode() if data else None
    req = urllib.request.Request(url, data=body, headers=headers, method=method)

    try:
        with urllib.request.urlopen(req) as resp:
            return resp.status, json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        try:
            return e.code, json.loads(body)
        except:
            return e.code, {"error": {"message": body}}

def wait_for_operation(op_name, token=None, quota_project=None):
    """Wait for a long-running operation to complete"""
    if not op_name:
        return None

    # Determine the base URL from the operation name
    if op_name.startswith("operations/"):
        url = f"https://firebase.googleapis.com/v1beta1/{op_name}"
    elif "firestore" in op_name:
        url = f"https://firestore.googleapis.com/v1/{op_name}"
    elif "identitytoolkit" in op_name:
        url = f"https://identitytoolkit.googleapis.com/{op_name}"
    else:
        url = f"https://cloudresourcemanager.googleapis.com/v1/{op_name}"

    for i in range(60):
        status, resp = api_call("GET", url, token=token, quota_project=quota_project)
        if status == 200:
            done = resp.get("done", False)
            if done:
                if "error" in resp:
                    print(f"  ✗ Operation failed: {resp['error']}")
                    return None
                return resp.get("response", resp)
            print(f"  ... waiting ({i+1}/60)")
            time.sleep(5)
        else:
            print(f"  ✗ Failed to check operation: {status} {resp}")
            return None
    print("  ✗ Operation timed out")
    return None

def step1_create_project():
    """Step 1: Create GCP project"""
    print("\n" + "="*60)
    print("STEP 1: Create GCP Project")
    print("="*60)

    # Check if project already exists
    token = get_token()
    status, resp = api_call(
        "GET",
        f"https://cloudresourcemanager.googleapis.com/v1/projects/{NEW_PROJECT_ID}",
        token=token
    )

    if status == 200 and resp.get("lifecycleState") == "ACTIVE":
        print(f"  ✓ Project {NEW_PROJECT_ID} already exists!")
        return True

    # Try to create project
    print(f"  Creating project {NEW_PROJECT_ID}...")
    status, resp = api_call(
        "POST",
        "https://cloudresourcemanager.googleapis.com/v1/projects",
        data={
            "projectId": NEW_PROJECT_ID,
            "name": NEW_PROJECT_NAME,
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200 or status == 201:
        op_name = resp.get("name")
        print(f"  Operation started: {op_name}")
        result = wait_for_operation(op_name, token=token, quota_project=OLD_PROJECT_ID)
        if result:
            print(f"  ✓ Project created successfully!")
            return True

    if status == 409:
        print(f"  ✓ Project already exists (409 conflict)")
        return True

    print(f"  ✗ Failed to create project: {status}")
    print(f"    Error: {json.dumps(resp, indent=2)}")
    return False

def step1b_add_firebase():
    """Step 1b: Add Firebase to the project"""
    print("\n" + "="*60)
    print("STEP 1b: Add Firebase to Project")
    print("="*60)

    token = get_token()

    # Check if Firebase is already added
    status, resp = api_call(
        "GET",
        f"https://firebase.googleapis.com/v1beta1/projects/{NEW_PROJECT_ID}",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ Firebase already enabled for {NEW_PROJECT_ID}")
        return True

    # Add Firebase
    print(f"  Adding Firebase to {NEW_PROJECT_ID}...")
    status, resp = api_call(
        "POST",
        f"https://firebase.googleapis.com/v1beta1/projects/{NEW_PROJECT_ID}:addFirebase",
        data={},
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        op_name = resp.get("name")
        print(f"  Operation started: {op_name}")
        result = wait_for_operation(op_name, token=token, quota_project=OLD_PROJECT_ID)
        if result:
            print(f"  ✓ Firebase added successfully!")
            return True

    print(f"  ✗ Failed to add Firebase: {status}")
    print(f"    Error: {json.dumps(resp, indent=2)}")
    return False

def step1c_create_web_app():
    """Step 1c: Create Firebase Web App"""
    print("\n" + "="*60)
    print("STEP 1c: Create Firebase Web App")
    print("="*60)

    token = get_token()

    # List existing web apps
    status, resp = api_call(
        "GET",
        f"https://firebase.googleapis.com/v1beta1/projects/{NEW_PROJECT_ID}/webApps",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        apps = resp.get("apps", [])
        if apps:
            app_id = apps[0].get("appId")
            print(f"  ✓ Web app already exists: {app_id}")
            return get_web_app_config(apps[0].get("name"), token)

    # Create web app
    print(f"  Creating web app for {NEW_PROJECT_ID}...")
    status, resp = api_call(
        "POST",
        f"https://firebase.googleapis.com/v1beta1/projects/{NEW_PROJECT_ID}/webApps",
        data={"displayName": NEW_PROJECT_NAME},
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        op_name = resp.get("name")
        print(f"  Operation started: {op_name}")
        result = wait_for_operation(op_name, token=token, quota_project=OLD_PROJECT_ID)
        if result:
            app_name = result.get("name", "")
            print(f"  ✓ Web app created: {result.get('appId')}")
            return get_web_app_config(app_name, token)

    print(f"  ✗ Failed to create web app: {status}")
    print(f"    Error: {json.dumps(resp, indent=2)}")
    return None

def get_web_app_config(app_name, token):
    """Get web app Firebase config"""
    if not app_name:
        return None

    status, resp = api_call(
        "GET",
        f"https://firebase.googleapis.com/v1beta1/{app_name}/config",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        config = {
            "apiKey": resp.get("apiKey", ""),
            "authDomain": resp.get("authDomain", ""),
            "projectId": resp.get("projectId", ""),
            "storageBucket": resp.get("storageBucket", ""),
            "messagingSenderId": resp.get("messagingSenderId", ""),
            "appId": resp.get("appId", ""),
        }
        print(f"  ✓ Got web app config:")
        for k, v in config.items():
            print(f"    {k}: {v}")
        return config

    print(f"  ✗ Failed to get config: {status} {resp}")
    return None

def step1d_enable_apis():
    """Enable required APIs on the new project"""
    print("\n" + "="*60)
    print("STEP 1d: Enable Required APIs")
    print("="*60)

    token = get_token()
    apis = [
        "firestore.googleapis.com",
        "identitytoolkit.googleapis.com",
        "firebaserules.googleapis.com",
        "firebase.googleapis.com",
    ]

    for api in apis:
        print(f"  Enabling {api}...")
        status, resp = api_call(
            "POST",
            f"https://serviceusage.googleapis.com/v1/projects/{NEW_PROJECT_ID}/services/{api}:enable",
            data={},
            token=token,
            quota_project=OLD_PROJECT_ID
        )
        if status == 200:
            op = resp.get("name", "")
            if op:
                # Wait briefly for operation
                for _ in range(10):
                    s2, r2 = api_call("GET", f"https://serviceusage.googleapis.com/v1/{op}", token=token, quota_project=OLD_PROJECT_ID)
                    if s2 == 200 and r2.get("done"):
                        break
                    time.sleep(2)
            print(f"    ✓ {api} enabled")
        elif status == 409:
            print(f"    ✓ {api} already enabled")
        else:
            print(f"    ✗ Failed: {status} {json.dumps(resp)[:200]}")

def step1e_grant_sa_access():
    """Grant the SA access to the new project"""
    print("\n" + "="*60)
    print("STEP 1e: Grant SA Access to New Project")
    print("="*60)

    token = get_token()
    sa_email = "anu2026@insuwiki-j2h.iam.gserviceaccount.com"

    # Get current IAM policy
    status, resp = api_call(
        "POST",
        f"https://cloudresourcemanager.googleapis.com/v1/projects/{NEW_PROJECT_ID}:getIamPolicy",
        data={},
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status != 200:
        print(f"  ✗ Cannot get IAM policy: {status}")
        return False

    policy = resp
    bindings = policy.get("bindings", [])

    # Add owner role for SA
    sa_member = f"serviceAccount:{sa_email}"
    owner_binding = None
    for b in bindings:
        if b["role"] == "roles/owner":
            owner_binding = b
            break

    if owner_binding:
        if sa_member not in owner_binding.get("members", []):
            owner_binding["members"].append(sa_member)
    else:
        bindings.append({
            "role": "roles/owner",
            "members": [sa_member]
        })

    policy["bindings"] = bindings

    status, resp = api_call(
        "POST",
        f"https://cloudresourcemanager.googleapis.com/v1/projects/{NEW_PROJECT_ID}:setIamPolicy",
        data={"policy": policy},
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ SA granted owner access to {NEW_PROJECT_ID}")
        return True
    else:
        print(f"  ✗ Failed to set IAM: {status} {json.dumps(resp)[:200]}")
        return False

def step2_setup_auth():
    """Step 2: Setup Firebase Authentication with Google provider"""
    print("\n" + "="*60)
    print("STEP 2: Setup Firebase Authentication")
    print("="*60)

    token = get_token()

    # Enable Identity Platform
    print("  Enabling Identity Platform...")

    # First check if auth is already configured
    status, resp = api_call(
        "GET",
        f"https://identitytoolkit.googleapis.com/admin/v2/projects/{NEW_PROJECT_ID}/config",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ Identity Platform already configured")
    else:
        # Initialize Identity Platform
        status, resp = api_call(
            "PATCH",
            f"https://identitytoolkit.googleapis.com/admin/v2/projects/{NEW_PROJECT_ID}/config",
            data={
                "signIn": {
                    "email": {"enabled": False},
                    "phoneNumber": {"enabled": False},
                },
                "authorizedDomains": [
                    "localhost",
                    f"{NEW_PROJECT_ID}.firebaseapp.com",
                    f"{NEW_PROJECT_ID}.web.app",
                    "100.76.130.39"
                ]
            },
            token=token,
            quota_project=OLD_PROJECT_ID
        )
        if status == 200:
            print(f"  ✓ Identity Platform configured")
        else:
            print(f"  ✗ Failed: {status} {json.dumps(resp)[:200]}")

    # Enable Google Sign-In provider
    print("  Enabling Google Sign-In provider...")

    # Get current IdP config
    status, resp = api_call(
        "GET",
        f"https://identitytoolkit.googleapis.com/admin/v2/projects/{NEW_PROJECT_ID}/defaultSupportedIdpConfigs/google.com",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ Google Sign-In already enabled")
    else:
        # Need OAuth client ID and secret for Google Sign-In
        # Create OAuth client for the new project
        status, resp = api_call(
            "POST",
            f"https://identitytoolkit.googleapis.com/admin/v2/projects/{NEW_PROJECT_ID}/defaultSupportedIdpConfigs?idpId=google.com",
            data={
                "enabled": True,
                "clientId": "",  # Will be auto-generated
                "clientSecret": "",
            },
            token=token,
            quota_project=OLD_PROJECT_ID
        )
        if status == 200:
            print(f"  ✓ Google Sign-In provider enabled")
        else:
            print(f"  ✗ Failed to enable Google Sign-In: {status} {json.dumps(resp)[:300]}")

    # Add authorized domains
    print("  Setting authorized domains...")
    status, resp = api_call(
        "PATCH",
        f"https://identitytoolkit.googleapis.com/admin/v2/projects/{NEW_PROJECT_ID}/config?updateMask=authorizedDomains",
        data={
            "authorizedDomains": [
                "localhost",
                f"{NEW_PROJECT_ID}.firebaseapp.com",
                f"{NEW_PROJECT_ID}.web.app",
                "100.76.130.39"
            ]
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )
    if status == 200:
        print(f"  ✓ Authorized domains set")
    else:
        print(f"  ✗ Failed to set domains: {status} {json.dumps(resp)[:200]}")

    return True

def step3_create_firestore():
    """Step 3: Create Firestore database"""
    print("\n" + "="*60)
    print("STEP 3: Create Firestore Database")
    print("="*60)

    token = get_token()

    # Check if Firestore already exists
    status, resp = api_call(
        "GET",
        f"https://firestore.googleapis.com/v1/projects/{NEW_PROJECT_ID}/databases/(default)",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ Firestore database already exists")
        return True

    # Create Firestore database
    print(f"  Creating Firestore database in {REGION}...")
    status, resp = api_call(
        "POST",
        f"https://firestore.googleapis.com/v1/projects/{NEW_PROJECT_ID}/databases?databaseId=(default)",
        data={
            "type": "FIRESTORE_NATIVE",
            "locationId": REGION,
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        op_name = resp.get("name")
        print(f"  Operation started: {op_name}")
        if op_name:
            result = wait_for_operation(op_name, token=token, quota_project=OLD_PROJECT_ID)
            if result:
                print(f"  ✓ Firestore database created!")
                return True

    print(f"  ✗ Failed to create Firestore: {status}")
    print(f"    Error: {json.dumps(resp, indent=2)}")
    return False

def step3b_deploy_rules():
    """Step 3b: Deploy Firestore security rules"""
    print("\n" + "="*60)
    print("STEP 3b: Deploy Firestore Security Rules")
    print("="*60)

    token = get_token()

    # Read rules file
    rules_path = os.path.join(INFOKEYWORD_DIR, "firestore.rules")
    with open(rules_path, "r") as f:
        rules_content = f.read()

    print(f"  Rules file: {rules_path}")
    print(f"  Rules length: {len(rules_content)} chars")

    # Create ruleset
    print("  Creating ruleset...")
    status, resp = api_call(
        "POST",
        f"https://firebaserules.googleapis.com/v1/projects/{NEW_PROJECT_ID}/rulesets",
        data={
            "source": {
                "files": [
                    {
                        "name": "firestore.rules",
                        "content": rules_content
                    }
                ]
            }
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status != 200:
        print(f"  ✗ Failed to create ruleset: {status} {json.dumps(resp)[:300]}")
        return False

    ruleset_name = resp.get("name", "")
    print(f"  ✓ Ruleset created: {ruleset_name}")

    # Release (deploy) the ruleset
    print("  Deploying ruleset...")
    release_name = f"projects/{NEW_PROJECT_ID}/releases/cloud.firestore"

    # Check if release exists
    status2, resp2 = api_call(
        "GET",
        f"https://firebaserules.googleapis.com/v1/{release_name}",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status2 == 200:
        # Update existing release
        status, resp = api_call(
            "PATCH",
            f"https://firebaserules.googleapis.com/v1/{release_name}",
            data={
                "release": {
                    "name": release_name,
                    "rulesetName": ruleset_name,
                }
            },
            token=token,
            quota_project=OLD_PROJECT_ID
        )
    else:
        # Create new release
        status, resp = api_call(
            "POST",
            f"https://firebaserules.googleapis.com/v1/projects/{NEW_PROJECT_ID}/releases",
            data={
                "name": release_name,
                "rulesetName": ruleset_name,
            },
            token=token,
            quota_project=OLD_PROJECT_ID
        )

    if status == 200:
        print(f"  ✓ Rules deployed successfully!")
        return True
    else:
        print(f"  ✗ Failed to deploy rules: {status} {json.dumps(resp)[:300]}")
        return False

def step4_create_index():
    """Step 4: Create Firestore composite index"""
    print("\n" + "="*60)
    print("STEP 4: Create Firestore Composite Index")
    print("="*60)

    token = get_token()

    # Check existing indexes
    status, resp = api_call(
        "GET",
        f"https://firestore.googleapis.com/v1/projects/{NEW_PROJECT_ID}/databases/(default)/collectionGroups/ik_analyses/indexes",
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        indexes = resp.get("indexes", [])
        for idx in indexes:
            fields = idx.get("fields", [])
            field_names = [f.get("fieldPath") for f in fields]
            if "userId" in field_names and "createdAt" in field_names:
                print(f"  ✓ Composite index already exists")
                return True

    # Create composite index: userId(ASC) + createdAt(DESC)
    print("  Creating composite index: ik_analyses(userId ASC, createdAt DESC)...")
    status, resp = api_call(
        "POST",
        f"https://firestore.googleapis.com/v1/projects/{NEW_PROJECT_ID}/databases/(default)/collectionGroups/ik_analyses/indexes",
        data={
            "queryScope": "COLLECTION",
            "fields": [
                {"fieldPath": "userId", "order": "ASCENDING"},
                {"fieldPath": "createdAt", "order": "DESCENDING"},
            ]
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        op_name = resp.get("name")
        print(f"  ✓ Index creation started: {op_name}")
        print("  (Index building may take several minutes)")
        return True
    elif status == 409:
        print(f"  ✓ Index already exists (409)")
        return True
    else:
        print(f"  ✗ Failed to create index: {status} {json.dumps(resp)[:300]}")
        return False

def step5_update_env(config):
    """Step 5: Update .env.local with new project config"""
    print("\n" + "="*60)
    print("STEP 5: Update Environment Variables")
    print("="*60)

    if not config:
        print("  ✗ No config available to update .env.local")
        return False

    env_path = os.path.join(INFOKEYWORD_DIR, ".env.local")

    # Read current .env.local
    with open(env_path, "r") as f:
        current = f.read()

    print(f"  Current .env.local:")
    for line in current.strip().split("\n"):
        if "FIREBASE" in line:
            key = line.split("=")[0]
            print(f"    {key}=***")

    # Build new .env.local
    lines = current.strip().split("\n")
    new_lines = []
    firebase_keys = {
        "NEXT_PUBLIC_FIREBASE_API_KEY": config.get("apiKey", ""),
        "NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN": config.get("authDomain", ""),
        "NEXT_PUBLIC_FIREBASE_PROJECT_ID": config.get("projectId", ""),
        "NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET": config.get("storageBucket", ""),
        "NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID": config.get("messagingSenderId", ""),
        "NEXT_PUBLIC_FIREBASE_APP_ID": config.get("appId", ""),
    }

    for line in lines:
        key = line.split("=")[0] if "=" in line else ""
        if key in firebase_keys:
            new_lines.append(f"{key}={firebase_keys[key]}")
            del firebase_keys[key]
        else:
            new_lines.append(line)

    # Add any remaining keys that weren't in the original file
    for key, value in firebase_keys.items():
        new_lines.append(f"{key}={value}")

    new_content = "\n".join(new_lines) + "\n"

    # Backup original
    backup_path = env_path + ".bak"
    with open(backup_path, "w") as f:
        f.write(current)
    print(f"  ✓ Backed up to {backup_path}")

    # Write new content
    with open(env_path, "w") as f:
        f.write(new_content)

    print(f"  ✓ Updated .env.local with new config:")
    for k, v in {
        "NEXT_PUBLIC_FIREBASE_API_KEY": config.get("apiKey", ""),
        "NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN": config.get("authDomain", ""),
        "NEXT_PUBLIC_FIREBASE_PROJECT_ID": config.get("projectId", ""),
        "NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET": config.get("storageBucket", ""),
        "NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID": config.get("messagingSenderId", ""),
        "NEXT_PUBLIC_FIREBASE_APP_ID": config.get("appId", ""),
    }.items():
        masked = v[:8] + "..." if len(v) > 10 else v
        print(f"    {k}={masked}")

    return True

def step5b_update_env_example(config):
    """Update .env.local.example with new project references"""
    print("\n  Updating .env.local.example...")

    if not config:
        return False

    example_path = os.path.join(INFOKEYWORD_DIR, ".env.local.example")

    new_content = f"""# Firebase Configuration (InfoKeyword - independent project)
NEXT_PUBLIC_FIREBASE_API_KEY=
NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN={config.get('authDomain', NEW_PROJECT_ID + '.firebaseapp.com')}
NEXT_PUBLIC_FIREBASE_PROJECT_ID={config.get('projectId', NEW_PROJECT_ID)}
NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET={config.get('storageBucket', NEW_PROJECT_ID + '.firebasestorage.app')}
NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID=
NEXT_PUBLIC_FIREBASE_APP_ID=
"""

    with open(example_path, "w") as f:
        f.write(new_content)

    print(f"  ✓ Updated .env.local.example")
    return True

def step6_redeploy_insuwiki_rules():
    """Step 6: Remove ik_ rules from InsuWiki and redeploy"""
    print("\n" + "="*60)
    print("STEP 6: Redeploy InsuWiki Rules (remove ik_ references)")
    print("="*60)

    token = get_token()

    # Read InsuWiki rules file
    rules_path = os.path.join(INSUWIKI_DIR, "firestore.rules")
    with open(rules_path, "r") as f:
        rules_content = f.read()

    # Verify no ik_ rules in InsWiki's firestore.rules
    if "ik_" in rules_content:
        print("  ⚠ WARNING: InsuWiki firestore.rules contains ik_ references!")
        print("  This needs manual review.")
    else:
        print("  ✓ InsuWiki firestore.rules has no ik_ references")

    print(f"  Rules file: {rules_path}")
    print(f"  Rules length: {len(rules_content)} chars")

    # Create ruleset for InsuWiki
    print("  Creating ruleset for InsuWiki...")
    status, resp = api_call(
        "POST",
        f"https://firebaserules.googleapis.com/v1/projects/{OLD_PROJECT_ID}/rulesets",
        data={
            "source": {
                "files": [
                    {
                        "name": "firestore.rules",
                        "content": rules_content
                    }
                ]
            }
        },
        token=token,
    )

    if status != 200:
        print(f"  ✗ Failed to create InsuWiki ruleset: {status} {json.dumps(resp)[:300]}")
        return False

    ruleset_name = resp.get("name", "")
    print(f"  ✓ InsuWiki ruleset created: {ruleset_name}")

    # Deploy the ruleset
    release_name = f"projects/{OLD_PROJECT_ID}/releases/cloud.firestore"

    # Check if release exists
    status2, resp2 = api_call(
        "GET",
        f"https://firebaserules.googleapis.com/v1/{release_name}",
        token=token,
    )

    if status2 == 200:
        status, resp = api_call(
            "PATCH",
            f"https://firebaserules.googleapis.com/v1/{release_name}",
            data={
                "release": {
                    "name": release_name,
                    "rulesetName": ruleset_name,
                }
            },
            token=token,
        )
    else:
        status, resp = api_call(
            "POST",
            f"https://firebaserules.googleapis.com/v1/projects/{OLD_PROJECT_ID}/releases",
            data={
                "name": release_name,
                "rulesetName": ruleset_name,
            },
            token=token,
        )

    if status == 200:
        print(f"  ✓ InsuWiki rules redeployed successfully!")
        return True
    else:
        print(f"  ✗ Failed to deploy InsuWiki rules: {status} {json.dumps(resp)[:300]}")
        return False

def step7_build_and_test():
    """Step 7: Build and test InfoKeyword"""
    print("\n" + "="*60)
    print("STEP 7: Build and Test")
    print("="*60)

    # npm run build
    print("  Running npm run build...")
    result = subprocess.run(
        ["npm", "run", "build"],
        cwd=INFOKEYWORD_DIR,
        capture_output=True,
        text=True,
        timeout=300
    )

    if result.returncode == 0:
        print("  ✓ npm run build succeeded!")
    else:
        print(f"  ✗ npm run build failed:")
        print(f"    stdout: {result.stdout[-500:]}")
        print(f"    stderr: {result.stderr[-500:]}")
        return False, False

    # npm test
    print("  Running npm test...")
    result = subprocess.run(
        ["npm", "test"],
        cwd=INFOKEYWORD_DIR,
        capture_output=True,
        text=True,
        timeout=300,
        env={**os.environ, "CI": "true"}
    )

    if result.returncode == 0:
        print("  ✓ npm test passed!")
        # Print test summary
        for line in result.stdout.split("\n"):
            if "Tests:" in line or "Test Suites:" in line or "PASS" in line or "FAIL" in line:
                print(f"    {line.strip()}")
    else:
        print(f"  ✗ npm test failed:")
        print(f"    stdout: {result.stdout[-500:]}")
        print(f"    stderr: {result.stderr[-500:]}")
        return True, False

    return True, True

def link_billing_account():
    """Link billing account to new project"""
    print("\n  Linking billing account...")
    token = get_token()

    status, resp = api_call(
        "PUT",
        f"https://cloudbilling.googleapis.com/v1/projects/{NEW_PROJECT_ID}/billingInfo",
        data={
            "billingAccountName": "billingAccounts/01F099-BCE8BC-89A521",
        },
        token=token,
        quota_project=OLD_PROJECT_ID
    )

    if status == 200:
        print(f"  ✓ Billing account linked")
        return True
    else:
        print(f"  ✗ Failed to link billing: {status} {json.dumps(resp)[:200]}")
        return False

def main():
    print("=" * 60)
    print("InfoKeyword Firebase 프로젝트 분리 자동화")
    print("=" * 60)
    print(f"New Project: {NEW_PROJECT_ID}")
    print(f"Old Project: {OLD_PROJECT_ID}")
    print(f"Region: {REGION}")

    results = {}
    config = None

    # Step 1: Create GCP project
    results["project_create"] = step1_create_project()

    if not results["project_create"]:
        print("\n⚠ GCP 프로젝트 생성 실패!")
        print("서비스 계정으로는 조직이 없는 환경에서 프로젝트를 생성할 수 없습니다.")
        print("수동으로 프로젝트를 생성해주세요:")
        print(f"  1. https://console.firebase.google.com/ 접속")
        print(f"  2. '프로젝트 추가' 클릭")
        print(f"  3. 프로젝트 이름: {NEW_PROJECT_NAME}")
        print(f"  4. 프로젝트 ID: {NEW_PROJECT_ID}")
        print("\n수동 생성 후 이 스크립트를 다시 실행하세요.")

        # Save results
        results_path = "/home/jay/workspace/teams/dev2/firebase-setup-result.json"
        with open(results_path, "w") as f:
            json.dump(results, f, indent=2)

        return results

    # Link billing
    link_billing_account()

    # Step 1b: Add Firebase
    results["firebase_add"] = step1b_add_firebase()

    if not results["firebase_add"]:
        print("\n⚠ Firebase 추가 실패. 나머지 단계를 건너뜁니다.")
        return results

    # Step 1c: Create Web App and get config
    config = step1c_create_web_app()
    results["web_app_config"] = config is not None

    # Step 1d: Enable APIs
    step1d_enable_apis()

    # Step 1e: Grant SA access (if not already)
    step1e_grant_sa_access()

    # Step 2: Setup Auth
    results["auth_setup"] = step2_setup_auth()

    # Step 3: Create Firestore
    results["firestore_create"] = step3_create_firestore()

    # Step 3b: Deploy rules
    if results["firestore_create"]:
        results["rules_deploy"] = step3b_deploy_rules()

    # Step 4: Create index
    if results["firestore_create"]:
        results["index_create"] = step4_create_index()

    # Step 5: Update env
    if config:
        results["env_update"] = step5_update_env(config)
        step5b_update_env_example(config)

    # Step 6: Redeploy InsuWiki rules
    results["insuwiki_redeploy"] = step6_redeploy_insuwiki_rules()

    # Step 7: Build and test
    if config:
        build_ok, test_ok = step7_build_and_test()
        results["build"] = build_ok
        results["test"] = test_ok

    # Summary
    print("\n" + "=" * 60)
    print("SUMMARY")
    print("=" * 60)
    for key, value in results.items():
        status = "✓" if value else "✗"
        print(f"  {status} {key}: {value}")

    # Save results
    results_path = "/home/jay/workspace/teams/dev2/firebase-setup-result.json"
    with open(results_path, "w") as f:
        json.dump(results, f, indent=2, default=str)
    print(f"\nResults saved to {results_path}")

    # Save config if available
    if config:
        config_path = "/home/jay/workspace/teams/dev2/firebase-config.json"
        with open(config_path, "w") as f:
            json.dump(config, f, indent=2)
        print(f"Config saved to {config_path}")

    return results

if __name__ == "__main__":
    main()