Datasets:

pebxcvi
/

PSHomeCacheDepot

import internetarchive
import os
import re
import time

ITEM_ID = "PSHomeMappedObjects"

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
FILE_LIST = os.path.join(SCRIPT_DIR, "log.txt")
SOURCE_DIR = r"Q:\PSHOME-INT\PSHomeCacheDepot\OBJECTS-MAPPED\ARCHIVE"

# SET THIS:
# "upload" = upload ZIP files using either normal folder scanning or log.txt, selected by UPLOAD_FROM_LOG
# "delete" = delete files listed in log.txt
MODE = "upload"

START_FOLDER = "0"
PAUSE_AFTER_EACH_FOLDER = False

# UPLOAD METHOD SWITCH:
# True  = send multiple ZIP files in each internetarchive.upload() request.
# False = send one ZIP file per internetarchive.upload() request.
UPLOAD_IN_BATCHES = True

# When UPLOAD_IN_BATCHES is True:
#   Number of ZIP files sent in each upload request.
#
# When UPLOAD_IN_BATCHES is False:
#   Files are still uploaded one per request, but this value controls
#   how many individual uploads occur before the optional batch pause.
UPLOAD_BATCH_SIZE = 50

# True  = pause after each group of UPLOAD_BATCH_SIZE files.
# False = continue automatically.
PAUSE_AFTER_EACH_UPLOAD_BATCH = False

# UPLOAD SOURCE SWITCH:
# False = normal mode: scan SOURCE_DIR folders 0-9/A-F starting at START_FOLDER.
# True  = log mode: upload only ZIP files listed in log.txt.
UPLOAD_FROM_LOG = False

# In log mode, entries may be:
#   17031A08-070245ED-A2766E0F-B1ACC605_T032
#   17031A08-070245ED-A2766E0F-B1ACC605_T032.zip
#   1/17031A08-070245ED-A2766E0F-B1ACC605_T032.zip
#   Q:\PSHOME-INT\PSHomeCacheDepot\OBJECTS-MAPPED\ARCHIVE\1\17031A08-070245ED-A2766E0F-B1ACC605_T032.zip
UPLOAD_LOG_FILE = FILE_LIST

# Archive.org upload safety settings.
# ZIP files normally do not need Archive.org derivatives, so leave this True.
NO_DERIVE = True

# Number of automatic retries after a 503 response.
# Leave at 0 so a global queue limit stops cleanly without re-uploading the same ZIP.
UPLOAD_RETRIES = 0

# Delay after each attempted file upload. Increase this if Archive.org throttles often.
UPLOAD_DELAY_SECONDS = 2.0

# Stop the entire run when Archive.org reports its global task queue is full.
# Continuing would only produce thousands of repeated failures.
STOP_ON_RATE_LIMIT = True

FOLDER_ORDER = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
UPLOAD_EXTS = {".zip"}
DELETE_EXTS = {".zip", ".torrent"}


def pause_exit():
    input("\nPress Enter to exit...")


def is_allowed_upload_file(name):
    return os.path.splitext(name)[1].lower() in UPLOAD_EXTS


def clean_name(line):
    text = line.strip().strip('"').strip("'").replace("\\", "/")
    return text.split("/")[-1].strip()


def normalize_delete_file_name(line):
    name = clean_name(line)

    if not name:
        return None

    root, ext = os.path.splitext(name)
    ext_low = ext.lower()

    if ext == "":
        return name + ".zip"

    if ext_low in DELETE_EXTS:
        return name

    return None


def normalize_delete_zip_name(line):
    name = clean_name(line)

    if not name:
        return None

    root, ext = os.path.splitext(name)
    ext_low = ext.lower()

    if ext == "":
        return name + ".zip"

    if ext_low == ".zip":
        return name

    return None


def normalize_delete_torrent_name(line):
    name = clean_name(line)

    if not name:
        return None

    root, ext = os.path.splitext(name)

    if ext.lower() == ".torrent":
        return name

    return None


def normalize_folder(folder):
    return folder.strip().upper()


def get_start_folders():
    start = normalize_folder(START_FOLDER)

    if start not in FOLDER_ORDER:
        raise ValueError(f"Invalid START_FOLDER: {START_FOLDER}")

    start_index = FOLDER_ORDER.index(start)
    return FOLDER_ORDER[start_index:]


def get_folder_from_zip_name(name):
    base = normalize_delete_zip_name(name)

    if not base:
        raise ValueError(f"Invalid zip filename: {name}")

    first = base[:1].upper()

    if first not in FOLDER_ORDER:
        raise ValueError(f"Cannot determine archive folder from filename: {name}")

    return first


def remote_name_from_zip_name(name):
    base = normalize_delete_zip_name(name)

    if not base:
        raise ValueError(f"Invalid zip filename: {name}")

    folder = get_folder_from_zip_name(base)
    return f"{folder}/{base}"


def remote_name_from_torrent_name(name):
    base = normalize_delete_torrent_name(name)

    if not base:
        raise ValueError(f"Invalid torrent filename: {name}")

    return base


def remote_name_from_delete_name(name):
    base = normalize_delete_file_name(name)

    if not base:
        raise ValueError(f"Unsupported delete filename: {name}")

    ext_low = os.path.splitext(base)[1].lower()

    if ext_low == ".zip":
        return remote_name_from_zip_name(base)

    if ext_low == ".torrent":
        return remote_name_from_torrent_name(base)

    raise ValueError(f"Unsupported delete filename: {name}")


def remote_name_from_local(source_dir, local_path):
    rel = os.path.relpath(local_path, source_dir)
    return rel.replace("\\", "/")


def scan_upload_folder(source_dir, folder):
    folder_path = os.path.join(source_dir, folder)

    if not os.path.isdir(folder_path):
        print(f"[WARN] Missing local folder: {folder_path}")
        return []

    entries = []
    seen_remote = set()

    for root, dirs, files in os.walk(folder_path):
        dirs.sort()
        files.sort()

        for file_name in files:
            if not is_allowed_upload_file(file_name):
                continue

            local_path = os.path.join(root, file_name)
            remote_name = remote_name_from_local(source_dir, local_path)
            low = remote_name.lower()

            if low in seen_remote:
                print(f"[WARN] Duplicate remote path skipped: {remote_name}")
                continue

            seen_remote.add(low)
            entries.append((remote_name, local_path))

    return entries



def normalize_upload_log_entry(line, source_dir):
    raw = line.strip().strip('"').strip("'")

    if not raw:
        return None

    raw = os.path.expandvars(os.path.expanduser(raw))
    normalized = raw.replace("\\", "/")

    if os.path.isabs(raw):
        local_path = os.path.normpath(raw)

        try:
            rel = os.path.relpath(local_path, source_dir)
        except ValueError:
            raise ValueError(f"Path is not on the same drive as SOURCE_DIR: {raw}")

        if rel == os.pardir or rel.startswith(os.pardir + os.sep):
            raise ValueError(f"Absolute path is outside SOURCE_DIR: {raw}")

        remote_name = rel.replace("\\", "/")

    else:
        normalized = normalized.lstrip("/")
        parts = [part for part in normalized.split("/") if part]

        if not parts:
            return None

        if len(parts) == 1:
            file_name = parts[0]
            root, ext = os.path.splitext(file_name)

            if not ext:
                file_name += ".zip"
            elif ext.lower() != ".zip":
                raise ValueError(f"Unsupported upload extension: {raw}")

            folder = file_name[:1].upper()

            if folder not in FOLDER_ORDER:
                raise ValueError(f"Cannot determine archive folder from filename: {raw}")

            remote_name = f"{folder}/{file_name}"

        else:
            remote_name = "/".join(parts)
            root, ext = os.path.splitext(remote_name)

            if not ext:
                remote_name += ".zip"
            elif ext.lower() != ".zip":
                raise ValueError(f"Unsupported upload extension: {raw}")

        local_path = os.path.join(source_dir, *remote_name.split("/"))

    remote_name = remote_name.replace("\\", "/")
    remote_parts = [part for part in remote_name.split("/") if part]

    if len(remote_parts) < 2:
        raise ValueError(f"Upload path must include a 0-9/A-F folder: {raw}")

    top_folder = remote_parts[0].upper()

    if top_folder not in FOLDER_ORDER:
        raise ValueError(f"Invalid top-level archive folder in upload entry: {raw}")

    remote_parts[0] = top_folder
    remote_name = "/".join(remote_parts)

    if os.path.splitext(remote_name)[1].lower() not in UPLOAD_EXTS:
        raise ValueError(f"Unsupported upload extension: {raw}")

    return remote_name, os.path.normpath(local_path)


def load_upload_entries_from_log(path, source_dir):
    if not os.path.isfile(path):
        raise FileNotFoundError(f"Missing upload log: {path}")

    entries = []
    seen = set()
    invalid = []

    with open(path, "r", encoding="utf-8-sig", errors="ignore") as f:
        for line_number, line in enumerate(f, start=1):
            if not line.strip():
                continue

            try:
                resolved = normalize_upload_log_entry(line, source_dir)
            except Exception as e:
                message = f"Line {line_number}: {e}"
                print(f"[WARN] {message}")
                invalid.append(message)
                continue

            if not resolved:
                continue

            remote_name, local_path = resolved
            low = remote_name.lower()

            if low in seen:
                print(f"[SKIP LOG DUPLICATE] {remote_name}")
                continue

            seen.add(low)
            entries.append((remote_name, local_path))

    return entries, invalid


def load_file_list(path):
    if not os.path.exists(path):
        raise FileNotFoundError(f"Missing file: {path}")

    with open(path, "r", encoding="utf-8", errors="ignore") as f:
        raw = [line.strip() for line in f if line.strip()]

    names = []
    seen = set()

    for line in raw:
        name = normalize_delete_file_name(line)

        if not name:
            continue

        low = name.lower()

        if low not in seen:
            seen.add(low)
            names.append(name)

    return names


def list_item_files(item_id):
    item = internetarchive.get_item(item_id)
    out = []

    for f in item.files:
        name = f.get("name")
        if name:
            out.append(name)

    return out


def chunks(items, size):
    for i in range(0, len(items), size):
        yield items[i:i + size]


def is_rate_limit_error(error_text):
    text = str(error_text).lower()

    rate_limit_markers = (
        "please reduce your request rate",
        "total_tasks_queued exceeds global_limit",
        "bucket_tasks_queued exceeds rationed amount",
        "503 slow down",
        "503 slowdown",
    )

    return any(marker in text for marker in rate_limit_markers)


def response_error_text(response):
    parts = []

    status_code = getattr(response, "status_code", None)
    if status_code is not None:
        parts.append(f"HTTP {status_code}")

    reason = getattr(response, "reason", None)
    if reason:
        parts.append(str(reason))

    body = getattr(response, "text", None)
    if body:
        parts.append(str(body))

    return " - ".join(parts)


def upload_file_batch(item_id, batch_entries, batch_number, total_batches):
    """
    Upload multiple files in one internetarchive.upload() request.
    Returns:
        status: "uploaded", "failed", or "rate_limited"
        uploaded_names: files accepted as uploaded
        failed_names: files that could not be submitted/uploaded
        message: error/rate-limit text or None
    """
    valid_entries = []
    failed_names = []

    print("--------------------------------------------------")

    if UPLOAD_IN_BATCHES:
        print(
            f"[UPLOAD BATCH {batch_number}/{total_batches}] "
            f"{len(batch_entries)} file(s)"
        )
    else:
        print(f"[UPLOAD FILE {batch_number}/{total_batches}]")

    print("--------------------------------------------------")

    for remote_name, local_path in batch_entries:
        if not os.path.isfile(local_path):
            print(f"[ERROR] Missing local file: {local_path}")
            failed_names.append(remote_name)
            continue

        valid_entries.append((remote_name, local_path))

    if not valid_entries:
        return "failed", [], failed_names, "No valid local files in this batch."

    upload_map = {
        remote_name: local_path
        for remote_name, local_path in valid_entries
    }

    if UPLOAD_IN_BATCHES:
        print(
            f"[INFO] Sending {len(upload_map)} file(s) "
            "in one Archive.org upload request."
        )
    else:
        print("[INFO] Sending 1 file in this Archive.org upload request.")

    try:
        result = internetarchive.upload(
            item_id,
            upload_map,
            verbose=True,
            queue_derive=not NO_DERIVE,
            retries=UPLOAD_RETRIES,
        )

        if result is not None:
            try:
                for response in result:
                    status_code = getattr(response, "status_code", None)

                    if status_code is not None and not (200 <= status_code < 300):
                        message = response_error_text(response)

                        if is_rate_limit_error(message):
                            print(f"[RATE LIMIT] {message}")
                            return (
                                "rate_limited",
                                [],
                                failed_names,
                                message,
                            )

                        print(f"[ERROR] Batch upload failed: {message}")
                        failed_names.extend(
                            remote_name
                            for remote_name, local_path in valid_entries
                        )
                        return "failed", [], failed_names, message

            except TypeError:
                # Some internetarchive versions return a non-iterable result.
                pass

        uploaded_names = [
            remote_name
            for remote_name, local_path in valid_entries
        ]

        if UPLOAD_IN_BATCHES:
            print(f"[OK] Uploaded batch: {len(uploaded_names)} file(s)")
        else:
            print(f"[OK] Uploaded: {uploaded_names[0]}")

        return "uploaded", uploaded_names, failed_names, None

    except Exception as e:
        message = str(e)

        if is_rate_limit_error(message):
            print(f"[RATE LIMIT] {message}")
            return "rate_limited", [], failed_names, message

        print(f"[ERROR] Batch upload failed: {message}")

        failed_names.extend(
            remote_name
            for remote_name, local_path in valid_entries
        )

        return "failed", [], failed_names, message

    finally:
        if UPLOAD_DELAY_SECONDS > 0:
            time.sleep(UPLOAD_DELAY_SECONDS)


def upload_entries(item_id, entries, remote_set):
    uploaded = []
    skipped = []
    failed = []
    deferred = []

    entries = list(entries)
    total = len(entries)

    pending_entries = []

    for index, (remote_name, local_path) in enumerate(entries, start=1):
        remote_low = remote_name.lower()

        if remote_low in remote_set:
            print(f"[SKIP {index}/{total}] Already uploaded: {remote_name}")
            skipped.append(remote_name)
            continue

        pending_entries.append((remote_name, local_path))

    if not pending_entries:
        print("[INFO] No new files remain to upload in this group.")
        return uploaded, skipped, failed, deferred, False

    configured_group_size = max(1, UPLOAD_BATCH_SIZE)

    if UPLOAD_IN_BATCHES:
        request_size = configured_group_size
    else:
        request_size = 1

    upload_batches = list(chunks(pending_entries, request_size))
    total_batches = len(upload_batches)

    print()
    print(f"[INFO] New files to upload: {len(pending_entries)}")

    if UPLOAD_IN_BATCHES:
        print("[INFO] Upload method: multiple files per request")
        print(f"[INFO] Files per upload request: {request_size}")
        print(f"[INFO] Number of upload requests: {total_batches}")
    else:
        print("[INFO] Upload method: one file per request")
        print(f"[INFO] Number of upload requests: {total_batches}")
        print(
            f"[INFO] Optional pause interval: every "
            f"{configured_group_size} individual upload(s)"
        )

    print()

    for batch_index, batch_entries in enumerate(upload_batches, start=1):
        status, batch_uploaded, batch_failed, message = upload_file_batch(
            item_id,
            batch_entries,
            batch_index,
            total_batches,
        )

        uploaded.extend(batch_uploaded)
        failed.extend(batch_failed)

        for remote_name in batch_uploaded:
            remote_set.add(remote_name.lower())

        print()

        if status == "rate_limited":
            deferred = []

            for remaining_batch in upload_batches[batch_index - 1:]:
                for pending_remote, pending_local in remaining_batch:
                    if pending_remote.lower() not in remote_set:
                        deferred.append(pending_remote)

            print("[INFO] Archive.org's upload/task queue is currently full.")
            print("[INFO] Stopping now instead of attempting the remaining batches.")
            print("[INFO] Rerun later; files already present remotely will be skipped.")

            if message:
                print(f"[INFO] Rate-limit message: {message}")

            return uploaded, skipped, failed, deferred, True

        should_pause = False

        if PAUSE_AFTER_EACH_UPLOAD_BATCH and batch_index < total_batches:
            if UPLOAD_IN_BATCHES:
                # Each request is one complete multi-file group.
                should_pause = True
            elif batch_index % configured_group_size == 0:
                # Individual mode: pause only after the configured number
                # of one-file upload requests, not after every single file.
                should_pause = True

        if should_pause:
            if UPLOAD_IN_BATCHES:
                pause_message = (
                    f"[BATCH PAUSE] Finished upload batch "
                    f"{batch_index}/{total_batches} "
                    f"({len(batch_entries)} file(s)). "
                    "Press Enter to continue..."
                )
            else:
                pause_message = (
                    f"[BATCH PAUSE] Finished {batch_index} individual "
                    f"upload(s). Press Enter to continue..."
                )

            input(pause_message)
            print()

    return uploaded, skipped, failed, deferred, False


def find_delete_targets(all_remote_files, file_names):
    remote_set = {x.lower() for x in all_remote_files}
    matches = []
    missing = []
    seen = set()

    for name in file_names:
        try:
            remote_name = remote_name_from_delete_name(name)
        except Exception as e:
            print(f"[WARN] {e}")
            missing.append(name)
            continue

        low = remote_name.lower()

        if low in remote_set:
            if low not in seen:
                seen.add(low)
                matches.append(remote_name)
        else:
            missing.append(remote_name)

    return matches, missing


def delete_remote_files(item_id, remote_names):
    deleted = []
    failed = []

    for name in remote_names:
        print(f"Deleting main file: {name}")

        try:
            internetarchive.delete(
                item_id,
                files=name,
                cascade_delete=False,
                verbose=True
            )
            print(f"[OK] Deleted: {name}")
            deleted.append(name)
        except Exception as e:
            print(f"[ERROR] Failed deleting {name}: {e}")
            failed.append(name)

        print()

    return deleted, failed


def find_matching_history_backups(all_remote_files, target_names):
    target_set = set()

    for name in target_names:
        try:
            target_set.add(remote_name_from_delete_name(name).lower())
        except Exception:
            pass

    matches = []
    pattern = re.compile(r"^history/files/(.+?)\.~\d+~$", re.IGNORECASE)

    for remote_name in all_remote_files:
        m = pattern.match(remote_name)

        if not m:
            continue

        backed_up_name = m.group(1).replace("\\", "/").lower()

        if backed_up_name in target_set:
            matches.append(remote_name)

    return matches


def delete_backup_files(item_id, backup_names):
    deleted = []
    failed = []

    for remote_name in backup_names:
        print(f"Deleting backup file: {remote_name}")

        try:
            internetarchive.delete(
                item_id,
                files=remote_name,
                cascade_delete=False,
                verbose=True
            )
            print(f"[OK] Deleted backup: {remote_name}")
            deleted.append(remote_name)
        except Exception as e:
            print(f"[ERROR] Failed deleting backup {remote_name}: {e}")
            failed.append(remote_name)

        print()

    return deleted, failed


def write_log(path, lines):
    with open(path, "w", encoding="utf-8", newline="") as f:
        for line in lines:
            f.write(str(line) + "\n")


def run_upload_mode(item_id, source_dir):
    print("[MODE] UPLOAD")
    print(f"[INFO] Source folder: {source_dir}")
    print(f"[INFO] Upload from log: {UPLOAD_FROM_LOG}")

    if UPLOAD_FROM_LOG:
        print(f"[INFO] Upload log: {UPLOAD_LOG_FILE}")
    else:
        print(f"[INFO] Start folder: {START_FOLDER}")

    print(f"[INFO] No derive: {NO_DERIVE}")
    print(f"[INFO] Upload retries: {UPLOAD_RETRIES}")
    print(f"[INFO] Delay between attempted uploads: {UPLOAD_DELAY_SECONDS} second(s)")

    print(f"[INFO] Upload in batches: {UPLOAD_IN_BATCHES}")
    print(f"[INFO] Upload group size: {UPLOAD_BATCH_SIZE} file(s)")
    print(f"[INFO] Pause after each upload group: {PAUSE_AFTER_EACH_UPLOAD_BATCH}")

    print()

    if not os.path.isdir(source_dir):
        print(f"[FATAL] Source folder not found: {source_dir}")
        pause_exit()
        return

    if UPLOAD_FROM_LOG:
        try:
            log_entries, invalid_log_entries = load_upload_entries_from_log(
                UPLOAD_LOG_FILE,
                source_dir,
            )
        except Exception as e:
            print(f"[FATAL] Could not load upload log: {e}")
            pause_exit()
            return

        if not log_entries:
            print(f"[WARN] No valid ZIP upload entries found in: {UPLOAD_LOG_FILE}")

            if invalid_log_entries:
                print(f"[INFO] Invalid upload log entries: {len(invalid_log_entries)}")

            pause_exit()
            return

        upload_groups = [("LOG", log_entries)]

        print(f"[OK] Loaded {len(log_entries)} unique ZIP upload entry/entries from log.txt.")

        if invalid_log_entries:
            print(f"[WARN] Ignored {len(invalid_log_entries)} invalid log entry/entries.")

        print()

    else:
        try:
            folders = get_start_folders()
        except Exception as e:
            print(f"[FATAL] {e}")
            pause_exit()
            return

        upload_groups = []

        for folder in folders:
            entries = scan_upload_folder(source_dir, folder)
            upload_groups.append((folder, entries))

    print("[INFO] Checking archive.org item for existing files...")

    try:
        remote_files = list_item_files(item_id)
        remote_set = {x.lower() for x in remote_files}
        print(f"[OK] Remote item has {len(remote_files)} file(s).")
    except Exception as e:
        print(f"[FATAL] Could not list archive.org item files: {e}")
        pause_exit()
        return

    print()

    all_uploaded = []
    all_skipped = []
    all_failed = []
    all_deferred = []
    stopped_for_rate_limit = False

    uploaded_log = os.path.join(SCRIPT_DIR, "uploaded_ok.txt")
    skipped_log = os.path.join(SCRIPT_DIR, "upload_skipped.txt")
    failed_log = os.path.join(SCRIPT_DIR, "upload_failed.txt")
    deferred_log = os.path.join(SCRIPT_DIR, "upload_deferred.txt")

    for group_name, upload_list in upload_groups:
        print("========================================")

        if group_name == "LOG":
            print("[UPLOAD LIST] log.txt")
        else:
            print(f"[FOLDER] {group_name}")

        print("========================================")

        if group_name == "LOG":
            print(f"[OK] Found {len(upload_list)} ZIP file(s) in the upload log.")
        else:
            print(f"[OK] Found {len(upload_list)} ZIP file(s) in folder {group_name}.")

        print()

        uploaded, skipped, failed, deferred, rate_limited = upload_entries(
            item_id,
            upload_list,
            remote_set,
        )

        all_uploaded.extend(uploaded)
        all_skipped.extend(skipped)
        all_failed.extend(failed)
        all_deferred.extend(deferred)

        write_log(uploaded_log, all_uploaded)
        write_log(skipped_log, all_skipped)
        write_log(failed_log, all_failed)
        write_log(deferred_log, all_deferred)

        if group_name == "LOG":
            print("========== LOG UPLOAD SUMMARY ==========")
        else:
            print(f"========== FOLDER {group_name} SUMMARY ==========")

        print(f"Found:             {len(upload_list)}")
        print(f"Uploaded:          {len(uploaded)}")
        print(f"Skipped existing:  {len(skipped)}")
        print(f"Failed:            {len(failed)}")
        print(f"Deferred:          {len(deferred)}")
        print()

        if rate_limited and STOP_ON_RATE_LIMIT:
            stopped_for_rate_limit = True
            break

        if not UPLOAD_FROM_LOG and PAUSE_AFTER_EACH_FOLDER:
            input(
                f"[PAUSE] Finished folder {group_name}. "
                "Press Enter to continue, or close this window to stop..."
            )

        print()

    print("========== FINAL SUMMARY ==========")
    print(f"Uploaded:          {len(all_uploaded)}")
    print(f"Skipped existing:  {len(all_skipped)}")
    print(f"Failed:            {len(all_failed)}")
    print(f"Deferred:          {len(all_deferred)}")
    print()
    print(f"Uploaded log: {uploaded_log}")
    print(f"Skipped log:  {skipped_log}")
    print(f"Failed log:   {failed_log}")
    print(f"Deferred log: {deferred_log}")

    if stopped_for_rate_limit:
        print()
        print("[STOPPED] Archive.org reported that its global task queue is full.")
        print("[INFO] This is a server-side limit, not a damaged ZIP or local network error.")
        print("[INFO] Run the script again later with the same upload source setting.")
        print("[INFO] The script will rescan the item and skip files that are already present.")

    if all_failed:
        print("\nActual failed uploads:")
        for name in all_failed:
            print(name)


def run_delete_mode(item_id, file_names):
    print("[MODE] DELETE")
    print(f"[OK] Loaded {len(file_names)} supported delete file name(s) from {FILE_LIST}")
    print()

    print("[INFO] Scanning item files...")

    try:
        all_files = list_item_files(item_id)
    except Exception as e:
        print(f"[ERROR] Could not scan item files: {e}")
        pause_exit()
        return

    delete_targets, missing_targets = find_delete_targets(all_files, file_names)
    backup_matches = find_matching_history_backups(all_files, file_names)

    print(f"[INFO] Found {len(delete_targets)} matching main file(s).")
    print(f"[INFO] Missing {len(missing_targets)} requested file(s).")
    print(f"[INFO] Found {len(backup_matches)} matching backup file(s).")
    print()

    delete_target_log = os.path.join(SCRIPT_DIR, "delete_ok.txt")
    missing_target_log = os.path.join(SCRIPT_DIR, "delete_missing.txt")

    write_log(delete_target_log, delete_targets)
    write_log(missing_target_log, missing_targets)

    deleted_main, delete_failed = delete_remote_files(item_id, delete_targets)

    if backup_matches:
        deleted_backups, backup_failed = delete_backup_files(item_id, backup_matches)
    else:
        deleted_backups = []
        backup_failed = []

    print("========== SUMMARY ==========")
    print(f"Files requested:   {len(file_names)}")
    print(f"Main matched:      {len(delete_targets)}")
    print(f"Main missing:      {len(missing_targets)}")
    print(f"Main deleted:      {len(deleted_main)}")
    print(f"Main delete fail:  {len(delete_failed)}")
    print(f"Backups matched:   {len(backup_matches)}")
    print(f"Backups deleted:   {len(deleted_backups)}")
    print(f"Backup del fail:   {len(backup_failed)}")
    print()
    print(f"Resolved delete target log: {delete_target_log}")
    print(f"Missing delete target log:  {missing_target_log}")

    if delete_failed:
        print("\nFailed main deletes:")
        for name in delete_failed:
            print(name)

    if backup_failed:
        print("\nFailed backup deletes:")
        for name in backup_failed:
            print(name)


def main():
    mode = MODE.strip().lower()

    if mode == "upload":
        run_upload_mode(ITEM_ID, SOURCE_DIR)

    elif mode == "delete":
        try:
            file_names = load_file_list(FILE_LIST)
        except Exception as e:
            print(f"[FATAL] {e}")
            pause_exit()
            return

        if not file_names:
            print(f"[WARN] No supported delete entries found in: {FILE_LIST}")
            print("[INFO] Supported delete entries: .zip, no-extension zip names, and .torrent files.")
            pause_exit()
            return

        run_delete_mode(ITEM_ID, file_names)

    else:
        print(f"[FATAL] Invalid MODE: {MODE}")
        print('Use MODE = "upload" or MODE = "delete"')
        pause_exit()
        return

    print("\nDone.")
    pause_exit()


if __name__ == "__main__":
    main()