OBJECTCATALOGUES/scripts/2-combine_tables.py

import csv
import os
import re
from pathlib import Path
from collections import defaultdict


SCRIPT_DIR = Path(__file__).resolve().parent
BASE_DIR = SCRIPT_DIR.parent
TABLEDUMPS_DIR = BASE_DIR / "TABLEDUMPS"

OBJECTS_SUFFIX = "_Objects.csv"
METADATA_SUFFIX = "_Metadata.csv"
COMBINED_SUFFIX = "_Combined.csv"

ERROR_LOG = BASE_DIR / "errors.log"

REMOVE_OBJECT_COLUMNS = {
    "Location",
    "InventoryEntryType",
    "EntitlementIndex",
    "RewardIndex",
    "UserLocation",
    "UserDateLastUsed",
}

METADATA_COLUMNS = [
    "CLOTHING",
    "RIGS",
    "GENDER",
    "PORTABLE",
    "MINI_GAME",
    "ACTIVE",
    "TARGETABLE",
    "ARCADE_GAME",
    "FURNITURE",
    "HOST_HEAT",
    "MAIN_HEAT",
    "NET_HEAT",
    "PPU_HEAT",
    "VRAM_HEAT",
    "EMBEDDED_OBJECT",
    "SCENE_ENTITLEMENT",
    "SCENE_TYPE",
    "TAGS",
    "WORLD_MAP",
    "LEGAL_TAG",
    "CLAN",
    "LPID",
    "CATEGORY_ID",
    "PRODUCT_ID",
    "ENTITLEMENT_ID",
    "COMMUNICATION_ID",
    "TITLE_ID",
]

TYPE_COLUMNS = [
    "CLOTHING",
    "GENDER",
    "PORTABLE",
    "MINI_GAME",
    "ARCADE_GAME",
    "FURNITURE",
    "ACTIVE",
    "TARGETABLE",
    "SCENE_ENTITLEMENT",
    "SCENE_TYPE",
    "EMBEDDED_OBJECT",
]

TYPE_COLUMNS_MINIGAME_AFTER_FURNITURE = [
    "CLOTHING",
    "GENDER",
    "PORTABLE",
    "ARCADE_GAME",
    "FURNITURE",
    "MINI_GAME",
    "ACTIVE",
    "TARGETABLE",
    "SCENE_ENTITLEMENT",
    "SCENE_TYPE",
    "EMBEDDED_OBJECT",
]

TYPE_TITLE_ONLY_COLUMNS = {
    "PORTABLE",
    "MINI_GAME",
    "ACTIVE",
    "TARGETABLE",
    "ARCADE_GAME",
    "EMBEDDED_OBJECT",
}

TYPE_TITLE_AND_VALUE_COLUMNS = {
    "CLOTHING",
    "FURNITURE",
    "SCENE_TYPE",
    "SCENE_ENTITLEMENT",
}

SORT_VALUES_COLUMNS = {
    "WORLD_MAP",
    "CATEGORY_ID",
    "PRODUCT_ID",
    "ENTITLEMENT_ID",
}

GENDER_RIGS = {
    "00000000-00000000-00000010-00000000": "MALE",
    "00000000-00000000-00000010-00000001": "FEMALE",
}

CLOTHING_REPLACEMENTS = {
    "TORS|LEGS": "OUTFITS",
    "TORS|LEGS|FEET": "OUTFITS",
    "LEGS|FEET": "LEGS",
    "TORS|LEGS|FEET|OUTFITS": "OUTFITS",
    "TORSO": "TORS",
    "TORS|LEGS|OUTFITS": "OUTFITS",
    "LEGS|TORS|FEET": "OUTFITS",
    "TORS|AND|LEGS": "OUTFITS",
    "TORS|LEG": "OUTFITS",
}

CATEGORY_REPLACEMENTS = {
    "5|EVIL|RESIDENT|T-SHIRT": "RESIDENT|EVIL|5|T-SHIRT",
    "AND|BLACK|DENIM|LEGGINGS|RED|SHORTS|STILETTOS|WITH": "RED|STILETTOS|WITH|BLACK|DENIM|SHORTS|AND|LEGGINGS",
    "24-NPUR30151_00": "UP0024-NPUR30151_00",
    "LUA|REWARD": "LUA_REWARD",
    "UP9000-NPUQ0001_00": "UP9000-NPUQ00001_00",
    "UUP9000-NPUQ00001_00": "UP9000-NPUQ00001_00",
    "UP9000-NPUQ00010_": "UP9000-NPUQ00010_00",
    "HP9000-NPHQ00009": "HP9000-NPHQ00009_00",
    "HT4010-NPHR00022_00'": "HT4010-NPHR00022_00",
    "ET0002-NPER00035_00V": "ET0002-NPER00035_00",
    "JT4001-NPJR50210": "JT4001-NPJR50210_00",
    "JP9000-NPJQ50100": "JP9000-NPJQ50100_00",
    "JP9002-NPJQ50280": "JP9002-NPJQ50280_00",
    "JP0082-NPJR50150_0": "JP0082-NPJR50150_00",
    "JP0043-NPJR50420": "JP0043-NPJR50420_00",
}

PRODUCT_REPLACEMENTS = {
    "LUA|REWARD": "LUA_REWARD",
}

FURNITURE_REPLACEMENTS = {
    "PICTURE|FRAME": "FRAME",
}

DATE_PATTERN = re.compile(r"^(.*?)(\d{4}-\d{2}-\d{2})(.*)$")


def log_error(message):
    with open(ERROR_LOG, "a", encoding="utf-8", newline="\n") as log_file:
        log_file.write(message + "\n")


def strip_suffix(filename, suffix):
    if filename.endswith(suffix):
        return filename[:-len(suffix)]

    return filename


def get_catalogue_parts(stem):
    match = DATE_PATTERN.match(stem)

    if not match:
        return None

    prefix = match.group(1)
    date = match.group(2)
    suffix = match.group(3)

    return prefix, date, suffix


def get_objectcatalogue_5_date(stem):
    parts = stem.split("_")

    if len(parts) >= 4:
        date = parts[3]

        if re.fullmatch(r"\d{4}-\d{2}-\d{2}", date):
            return date

    return "0000-00-00"


def get_objectcatalogue_date(stem):
    parts = stem.split("_")

    if len(parts) >= 2:
        date = parts[1]

        if re.fullmatch(r"\d{4}-\d{2}-\d{2}", date):
            return date

    return "0000-00-00"


def find_objects_files():
    objects = {}

    for path in TABLEDUMPS_DIR.glob(f"*{OBJECTS_SUFFIX}"):
        stem = strip_suffix(path.name, OBJECTS_SUFFIX)
        objects[stem] = path

    return objects


def find_metadata_files():
    metadata = {}

    for path in TABLEDUMPS_DIR.glob(f"*{METADATA_SUFFIX}"):
        stem = strip_suffix(path.name, METADATA_SUFFIX)
        metadata[stem] = path

    return metadata


def catalogue_sort_key(stem):
    lower_stem = stem.lower()

    if lower_stem.startswith("objectcatalogue_"):
        return 0, lower_stem

    return 1, lower_stem


def find_best_objects_file(metadata_stem, objects_files):
    if metadata_stem in objects_files:
        return objects_files[metadata_stem]

    metadata_parts = get_catalogue_parts(metadata_stem)

    if metadata_parts is None:
        return None

    metadata_prefix, metadata_date, metadata_suffix = metadata_parts

    candidates = []

    for objects_stem, objects_path in objects_files.items():
        objects_parts = get_catalogue_parts(objects_stem)

        if objects_parts is None:
            continue

        objects_prefix, objects_date, objects_suffix = objects_parts

        if objects_prefix != metadata_prefix:
            continue

        if objects_suffix != metadata_suffix:
            continue

        if objects_date > metadata_date:
            continue

        candidates.append((objects_date, objects_path))

    if not candidates:
        return None

    candidates.sort(key=lambda item: item[0], reverse=True)

    return candidates[0][1]


def normalize_keyname(keyname):
    return keyname.strip().upper()


def version_to_txxx(version):
    version = str(version).strip()

    if not version:
        version = "0"

    try:
        version_int = int(version)
    except ValueError:
        version_int = 0

    return f"T{version_int:03d}"


def timestamp_to_hex(value):
    value = str(value).strip()

    if not value:
        return ""

    try:
        timestamp_int = int(value)
    except ValueError:
        return value.upper()

    return f"{timestamp_int:X}"


def normalize_joined_values(values):
    cleaned_values = []

    for value in values:
        value = str(value).strip().upper()

        if not value:
            continue

        cleaned_values.append(value)

    return "|".join(cleaned_values)


def add_field_name(column, value, has_keyname):
    if not has_keyname:
        return ""

    value = str(value).strip()

    if not value:
        return f"{column}|"

    return f"{column}|{value}|"


def strip_field_name(column, value):
    value = str(value).strip()

    prefix = f"{column}|"

    if value.startswith(prefix):
        value = value[len(prefix):]

    if value.endswith("|"):
        value = value[:-1]

    return value


def furniture_has_value(value):
    value = str(value).strip()

    if not value:
        return False

    if not value.startswith("FURNITURE|"):
        return False

    return value != "FURNITURE|"


def add_type_field_name(column, value):
    value = str(value).strip()

    if not value:
        return ""

    if column == "GENDER":
        return f"{value}|"

    if column in TYPE_TITLE_ONLY_COLUMNS:
        return f"{column}|"

    if column in TYPE_TITLE_AND_VALUE_COLUMNS:
        return value

    return value


def build_type_value(combined_row):
    type_value = ""

    if (
        furniture_has_value(combined_row.get("FURNITURE", ""))
        and combined_row.get("MINI_GAME", "")
    ):
        type_columns = TYPE_COLUMNS_MINIGAME_AFTER_FURNITURE
    else:
        type_columns = TYPE_COLUMNS

    for column in type_columns:
        value = add_type_field_name(
            column,
            combined_row.get(column, "")
        )

        if value:
            type_value += value

    return type_value


def normalize_clothing_values(values):
    joined_value = normalize_joined_values(values)

    return CLOTHING_REPLACEMENTS.get(joined_value, joined_value)


def normalize_category_values(values):
    joined_value = normalize_joined_values(values)

    return CATEGORY_REPLACEMENTS.get(joined_value, joined_value)


def normalize_product_values(values):
    joined_value = normalize_joined_values(values)

    return PRODUCT_REPLACEMENTS.get(joined_value, joined_value)


def normalize_furniture_values(values):
    joined_value = normalize_joined_values(values)

    return FURNITURE_REPLACEMENTS.get(joined_value, joined_value)


def read_objects_csv(objects_path):
    with open(objects_path, "r", encoding="utf-8-sig", newline="") as csv_file:
        reader = csv.DictReader(csv_file)

        if reader.fieldnames is None:
            raise ValueError(f"Missing header: {objects_path}")

        if "ObjectIndex" not in reader.fieldnames:
            raise ValueError(f"Missing ObjectIndex column: {objects_path}")

        if "ObjectId" not in reader.fieldnames:
            raise ValueError(f"Missing ObjectId column: {objects_path}")

        if "Version" not in reader.fieldnames:
            raise ValueError(f"Missing Version column: {objects_path}")

        if "ArchiveTimeStamp" not in reader.fieldnames:
            raise ValueError(f"Missing ArchiveTimeStamp column: {objects_path}")

        objects_header = [
            column
            for column in reader.fieldnames
            if column not in REMOVE_OBJECT_COLUMNS
        ]

        final_objects_header = []

        for column in objects_header:
            final_objects_header.append(column)

            if column == "Version":
                final_objects_header.append("UUID_TXXX")

            if column == "ArchiveTimeStamp":
                final_objects_header.append("ArchiveTimeStampHex")

            if column == "OdcSha1Digest":
                final_objects_header.append("TYPE")

        rows = []

        for row in reader:
            object_index = row.get("ObjectIndex", "").strip()

            if not object_index:
                log_error(f"[WARN] Blank ObjectIndex in Objects CSV: {objects_path}")
                continue

            object_id = row.get("ObjectId", "").strip()
            version = row.get("Version", "").strip()
            archive_timestamp = row.get("ArchiveTimeStamp", "").strip()

            row["UUID_TXXX"] = f"{object_id}_{version_to_txxx(version)}"
            row["ArchiveTimeStampHex"] = timestamp_to_hex(archive_timestamp)
            row["TYPE"] = ""

            clean_row = {}

            for column in final_objects_header:
                clean_row[column] = row.get(column, "")

            rows.append(clean_row)

    return final_objects_header, rows


def read_metadata_csv(metadata_path):
    metadata_by_object_index = defaultdict(lambda: defaultdict(list))
    unknown_keynames = set()

    with open(metadata_path, "r", encoding="utf-8-sig", newline="") as csv_file:
        reader = csv.DictReader(csv_file)

        if reader.fieldnames is None:
            raise ValueError(f"Missing header: {metadata_path}")

        required_columns = {"ObjectIndex", "KeyName", "Value"}
        missing_columns = required_columns - set(reader.fieldnames)

        if missing_columns:
            raise ValueError(
                f"Missing Metadata column(s) {sorted(missing_columns)}: {metadata_path}"
            )

        for row_number, row in enumerate(reader, start=2):
            object_index = row.get("ObjectIndex", "").strip()
            raw_keyname = row.get("KeyName", "").strip()
            value = row.get("Value", "")

            if not object_index:
                log_error(
                    f"[WARN] Blank ObjectIndex in Metadata CSV: {metadata_path}, row {row_number}"
                )
                continue

            if not raw_keyname:
                log_error(
                    f"[WARN] Blank KeyName in Metadata CSV: {metadata_path}, row {row_number}"
                )
                continue

            keyname = normalize_keyname(raw_keyname)

            if keyname not in METADATA_COLUMNS:
                unknown_keynames.add(raw_keyname)
                continue

            metadata_by_object_index[object_index][keyname].append(value)

    for keyname in sorted(unknown_keynames):
        log_error(f"[UNKNOWN KEYNAME] {metadata_path.name}: {keyname}")

    return metadata_by_object_index


def get_gender_from_rigs(rig_values):
    gender_values = []

    for rig_value in rig_values:
        rig_value = str(rig_value).strip()
        gender = GENDER_RIGS.get(rig_value)

        if gender is None:
            continue

        if gender not in gender_values:
            gender_values.append(gender)

    return "|".join(gender_values)


def combine_pair(objects_path, metadata_path):
    metadata_stem = strip_suffix(metadata_path.name, METADATA_SUFFIX)
    output_path = TABLEDUMPS_DIR / f"{metadata_stem}{COMBINED_SUFFIX}"

    if output_path.exists():
        print(f"[SKIP] Already exists, nothing changed: {output_path.name}")
        return

    objects_header, objects_rows = read_objects_csv(objects_path)
    metadata_by_object_index = read_metadata_csv(metadata_path)

    combined_header = objects_header + METADATA_COLUMNS

    with open(output_path, "w", encoding="utf-8", newline="") as csv_file:
        writer = csv.DictWriter(
            csv_file,
            fieldnames=combined_header,
            extrasaction="ignore"
        )

        writer.writeheader()

        for object_row in objects_rows:
            object_index = object_row.get("ObjectIndex", "").strip()
        
            metadata_values = metadata_by_object_index.get(object_index, {})
            combined_row = dict(object_row)
        
            for column in METADATA_COLUMNS:
                if column == "GENDER":
                    combined_row[column] = get_gender_from_rigs(
                        metadata_values.get("RIGS", [])
                    )
                    continue

                values = metadata_values.get(column, [])
                has_keyname = column in metadata_values

                if column in SORT_VALUES_COLUMNS:
                    values = sorted(values, key=str.lower)

                if column == "CLOTHING":
                    normalized_value = normalize_clothing_values(values)

                elif column == "CATEGORY_ID":
                    normalized_value = normalize_category_values(values)

                elif column == "PRODUCT_ID":
                    normalized_value = normalize_product_values(values)

                elif column == "FURNITURE":
                    normalized_value = normalize_furniture_values(values)

                else:
                    normalized_value = "|".join(values)

                combined_row[column] = add_field_name(
                    column,
                    normalized_value,
                    has_keyname
                )

            if not combined_row.get("CLOTHING", ""):
                rigs_value = combined_row.get("RIGS", "")

                if rigs_value.startswith("RIGS|"):
                    combined_row["CLOTHING"] = "CLOTHING|"

            if combined_row.get("FURNITURE", ""):
                rigs_value = combined_row.get("RIGS", "")

                if rigs_value.startswith("RIGS|"):
                    combined_row["RIGS"] = strip_field_name(
                        "RIGS",
                        rigs_value
                    )

            combined_row["TYPE"] = build_type_value(combined_row)

            writer.writerow(combined_row)

    print(f"[DONE] {output_path.name}")


def main():
    print(f"Script folder: {SCRIPT_DIR}")
    print(f"Base folder: {BASE_DIR}")
    print(f"Table dumps folder: {TABLEDUMPS_DIR}")
    print()

    if not TABLEDUMPS_DIR.exists():
        print("[ERROR] TABLEDUMPS folder does not exist.")
        print(f"Missing folder: {TABLEDUMPS_DIR}")
        input("")
        return

    if ERROR_LOG.exists():
        ERROR_LOG.unlink()

    objects_files = find_objects_files()
    metadata_files = find_metadata_files()

    print(f"Objects CSV files: {len(objects_files)}")
    print(f"Metadata CSV files: {len(metadata_files)}")
    print()

    if not objects_files:
        print("[ERROR] No *_Objects.csv files found.")
        input("")
        return

    if not metadata_files:
        print("[ERROR] No *_Metadata.csv files found.")
        input("")
        return

    objectcatalogue_5_stems = []
    objectcatalogue_stems = []
    other_stems = []

    for metadata_stem in metadata_files.keys():
        lower_stem = metadata_stem.lower()

        if lower_stem.startswith("objectcatalogue_5_"):
            objectcatalogue_5_stems.append(metadata_stem)

        elif lower_stem.startswith("objectcatalogue_"):
            objectcatalogue_stems.append(metadata_stem)

        else:
            other_stems.append(metadata_stem)

    sorted_metadata_stems = (
        sorted(
            objectcatalogue_5_stems,
            key=get_objectcatalogue_5_date,
            reverse=True
        )
        + sorted(
            objectcatalogue_stems,
            key=get_objectcatalogue_date,
            reverse=True
        )
        + sorted(other_stems, key=catalogue_sort_key)
    )

    for metadata_stem in sorted_metadata_stems:
        metadata_path = metadata_files[metadata_stem]
        objects_path = find_best_objects_file(metadata_stem, objects_files)

        if objects_path is None:
            log_error(f"[MISSING OBJECTS CSV] {metadata_path.name}")
            print(f"[SKIP] Missing Objects CSV for {metadata_path.name}")
            continue

        print(f"[COMBINE] {objects_path.name}")
        print(f"      + {metadata_path.name}")

        try:
            combine_pair(objects_path, metadata_path)
        except Exception as error:
            log_error(
                f"[ERROR] Failed combining {objects_path.name} + {metadata_path.name}: {error}"
            )
            print(f"[ERROR] {metadata_path.name}: {error}")

    print()

    if ERROR_LOG.exists():
        print(f"Finished with log: {ERROR_LOG}")
    else:
        print("Finished with no errors.")

    input("")


if __name__ == "__main__":
    main()