#!/usr/bin/env python3

from pathlib import Path
import shutil
import sys
import re
from datetime import datetime


ROOT = Path.cwd()

MESSENGER = ROOT / "packages/apps/LemenzoMessenger"
PHONE = ROOT / "packages/apps/LemenzoPhone"
CONTACTS = ROOT / "packages/apps/LemenzoContacts"

VENDOR = ROOT / "vendor/lemenzo"

OVERLAY_DIR = (
    VENDOR
    / "overlay"
    / "frameworks/base/core/res/res/values"
)

OVERLAY_FILE = OVERLAY_DIR / "config.xml"

PRODUCT_DIR = VENDOR / "product"
PRODUCT_FILE = PRODUCT_DIR / "lemenzo_communications.mk"


def fail(message):
    print(f"\n❌ ERROR: {message}")
    sys.exit(1)


def ok(message):
    print(f"✅ {message}")


def warning(message):
    print(f"⚠️  {message}")


def backup_file(path: Path):
    if not path.exists():
        return

    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
    backup = path.with_name(path.name + f".backup-{stamp}")
    shutil.copy2(path, backup)

    print(f"   Backup: {backup}")


def require_file(path: Path, description: str):
    if not path.is_file():
        fail(f"{description} mangler:\n{path}")


def require_dir(path: Path, description: str):
    if not path.is_dir():
        fail(f"{description} mangler:\n{path}")


print()
print("=" * 72)
print(" LemenzoOS Communication System Integration")
print("=" * 72)
print(f"Source root: {ROOT}")
print()


# ---------------------------------------------------------------------
# 1. Validate Android tree
# ---------------------------------------------------------------------

require_dir(ROOT / "frameworks/base", "frameworks/base")
require_dir(ROOT / "packages/apps", "packages/apps")
require_dir(ROOT / "build", "Android build tree")

ok("Android source-tree fundet")


# ---------------------------------------------------------------------
# 2. Validate Lemenzo Messenger
# ---------------------------------------------------------------------

require_dir(MESSENGER, "Lemenzo Messenger")
messenger_manifest = MESSENGER / "AndroidManifest.xml"
require_file(messenger_manifest, "Lemenzo Messenger AndroidManifest.xml")

messenger_xml = messenger_manifest.read_text(
    encoding="utf-8",
    errors="ignore",
)

required_messenger_entries = {
    "package": 'package="com.lemenzo.messenger"',
    "SENDTO": "android.intent.action.SENDTO",
    "smsto": 'android:scheme="smsto"',
    "SMS_DELIVER": "android.provider.Telephony.SMS_DELIVER",
    "WAP_PUSH_DELIVER": "android.provider.Telephony.WAP_PUSH_DELIVER",
    "RESPOND_VIA_MESSAGE": "android.intent.action.RESPOND_VIA_MESSAGE",
}

for name, value in required_messenger_entries.items():
    if value not in messenger_xml:
        fail(
            f"Lemenzo Messenger mangler required integration: {name}"
        )

ok("Lemenzo Messenger default-SMS contract er korrekt")


# ---------------------------------------------------------------------
# 3. Validate Lemenzo Phone
# ---------------------------------------------------------------------

require_dir(PHONE, "Lemenzo Phone")
phone_manifest = PHONE / "AndroidManifest.xml"
require_file(phone_manifest, "Lemenzo Phone AndroidManifest.xml")

phone_xml = phone_manifest.read_text(
    encoding="utf-8",
    errors="ignore",
)

if 'package="com.android.dialer"' not in phone_xml:
    fail(
        "Lemenzo Phone bruger ikke forventet package "
        "com.android.dialer. Stopper for ikke at gætte."
    )

ok("Lemenzo Phone package = com.android.dialer")


# ---------------------------------------------------------------------
# 4. Patch Phone -> Messenger messaging intents
# ---------------------------------------------------------------------

intent_util = (
    PHONE
    / "java/com/android/dialer/util/IntentUtil.java"
)

phone_number_interaction = (
    PHONE
    / "java/com/android/dialer/interactions/"
      "PhoneNumberInteraction.java"
)


def patch_java_file(path: Path):
    if not path.exists():
        warning(f"Kunne ikke finde {path}")
        return False

    original = path.read_text(
        encoding="utf-8",
        errors="ignore",
    )

    modified = original

    # Convert:
    # Uri.fromParts("sms", ...)
    # ->
    # Uri.fromParts("smsto", ...)

    modified = re.sub(
        r'Uri\.fromParts\(\s*"sms"\s*,',
        'Uri.fromParts("smsto",',
        modified,
    )

    # Convert literal "sms:" usage to "smsto:"
    # only in messaging URI constants.

    modified = modified.replace(
        'SMS_URI_PREFIX = "sms:"',
        'SMS_URI_PREFIX = "smsto:"'
    )

    # Handle old IntentUtil implementation if still present.
    modified = modified.replace(
        'Uri.parse(SMS_URI_PREFIX + phoneNumber)',
        'Uri.fromParts("smsto", String.valueOf(phoneNumber), null)'
    )

    if modified != original:
        backup_file(path)
        path.write_text(
            modified,
            encoding="utf-8",
        )

        ok(f"Patched Phone -> Messenger: {path}")
        return True

    if '"smsto"' in original or '"smsto:"' in original:
        ok(f"Allerede korrekt: {path}")
        return True

    warning(
        f"Ingen kendt SMS URI pattern fundet i {path}. "
        "Tjek filen manuelt."
    )
    return False


patch_java_file(intent_util)
patch_java_file(phone_number_interaction)


# ---------------------------------------------------------------------
# 5. Create framework role overlay
# ---------------------------------------------------------------------

OVERLAY_DIR.mkdir(
    parents=True,
    exist_ok=True,
)

overlay_contents = """<?xml version="1.0" encoding="utf-8"?>
<resources>

    <!--
        LemenzoOS communication role defaults.

        Lemenzo Messenger:
            package = com.lemenzo.messenger

        Lemenzo Phone:
            package = com.android.dialer
    -->

    <string
        name="config_defaultSms"
        translatable="false">com.lemenzo.messenger</string>

    <string
        name="default_sms_application"
        translatable="false">com.lemenzo.messenger</string>

    <string
        name="config_defaultDialer"
        translatable="false">com.android.dialer</string>

</resources>
"""

if OVERLAY_FILE.exists():
    current = OVERLAY_FILE.read_text(
        encoding="utf-8",
        errors="ignore",
    )

    if current != overlay_contents:
        backup_file(OVERLAY_FILE)

OVERLAY_FILE.write_text(
    overlay_contents,
    encoding="utf-8",
)

ok(
    "Android role overlay oprettet:\n"
    f"   {OVERLAY_FILE}"
)


# ---------------------------------------------------------------------
# 6. Create product integration fragment
# ---------------------------------------------------------------------

PRODUCT_DIR.mkdir(
    parents=True,
    exist_ok=True,
)

product_contents = """#
# LemenzoOS Communication Stack
#

PRODUCT_PACKAGES += \\
    LemenzoMessenger \\
    LemenzoPhone

PRODUCT_PACKAGE_OVERLAYS += \\
    vendor/lemenzo/overlay
"""

if PRODUCT_FILE.exists():
    current = PRODUCT_FILE.read_text(
        encoding="utf-8",
        errors="ignore",
    )

    if current != product_contents:
        backup_file(PRODUCT_FILE)

PRODUCT_FILE.write_text(
    product_contents,
    encoding="utf-8",
)

ok(
    "Product integration oprettet:\n"
    f"   {PRODUCT_FILE}"
)


# ---------------------------------------------------------------------
# 7. Inspect Lemenzo Contacts
# ---------------------------------------------------------------------

print()
print("--- Lemenzo Contacts ---")

if not CONTACTS.exists():
    warning(
        "packages/apps/LemenzoContacts findes ikke endnu.\n"
        "Contacts bliver derfor ikke ændret."
    )

else:
    contacts_manifest = CONTACTS / "AndroidManifest.xml"

    if contacts_manifest.exists():
        contacts_xml = contacts_manifest.read_text(
            encoding="utf-8",
            errors="ignore",
        )

        match = re.search(
            r'package="([^"]+)"',
            contacts_xml,
        )

        if match:
            contacts_package = match.group(1)
            ok(
                f"Lemenzo Contacts package fundet: "
                f"{contacts_package}"
            )
        else:
            warning(
                "Kunne ikke finde package i "
                "Lemenzo Contacts manifest"
            )

    # Scan for wrong direct sms: URIs.
    suspicious_files = []

    for path in CONTACTS.rglob("*.java"):
        text = path.read_text(
            encoding="utf-8",
            errors="ignore",
        )

        if (
            'Uri.fromParts("sms"' in text
            or '"sms:"' in text
        ):
            suspicious_files.append(path)

    if suspicious_files:
        print()
        warning(
            "Fandt Contacts-filer med sms: URI som bør "
            "ændres til smsto:"
        )

        for path in suspicious_files:
            print(f"   {path}")

    else:
        ok(
            "Ingen åbenlyse forkerte sms: URI'er "
            "fundet i Lemenzo Contacts"
        )


# ---------------------------------------------------------------------
# 8. Scan existing messaging packages
# ---------------------------------------------------------------------

print()
print("--- Existing SMS/Messaging packages ---")

search_roots = [
    ROOT / "packages/apps",
    ROOT / "packages/modules",
    ROOT / "vendor",
    ROOT / "device",
]

patterns = [
    "Messaging",
    "messaging",
    "com.android.messaging",
]

hits = []

for search_root in search_roots:
    if not search_root.exists():
        continue

    for filename in [
        "Android.bp",
        "Android.mk",
        "*.mk",
    ]:
        for path in search_root.rglob(filename):
            try:
                text = path.read_text(
                    encoding="utf-8",
                    errors="ignore",
                )
            except Exception:
                continue

            if any(pattern in text for pattern in patterns):
                if "LemenzoMessenger" not in str(path):
                    hits.append(path)


if hits:
    warning(
        "Mulige gamle/AOSP messaging references fundet.\n"
        "De bliver IKKE slettet automatisk, fordi vi først "
        "skal identificere den rigtige product inclusion:"
    )

    for path in sorted(set(hits))[:40]:
        print(f"   {path}")

else:
    ok(
        "Ingen åbenlyse gamle Messaging product references fundet"
    )


# ---------------------------------------------------------------------
# 9. Final verification
# ---------------------------------------------------------------------

print()
print("=" * 72)
print(" Integration complete")
print("=" * 72)

print()
print("Lemenzo Messenger:")
print("  ROLE_SMS -> com.lemenzo.messenger")

print()
print("Lemenzo Phone:")
print("  ROLE_DIALER -> com.android.dialer")

print()
print("Phone -> Messenger:")
print("  ACTION_SENDTO + smsto:")

print()
print("Messenger -> Phone:")
print("  ACTION_DIAL + tel:")

print()
print("Contacts:")
print("  Android ContactsProvider / ContactsContract")

print()
print("VIGTIGT:")
print()
print(
    "Tilføj følgende linje til dit aktive product/device makefile:"
)
print()
print(
    "$(call inherit-product, "
    "vendor/lemenzo/product/lemenzo_communications.mk)"
)
print()

print("Derefter build:")
print()
print("  source build/envsetup.sh")
print("  lunch <target>")
print("  m LemenzoMessenger LemenzoPhone")
print()

print("✅ Script finished")