TaikoNus3bankMake/TaikoSongConversionTool/gui.py

import glob
import gzip
import json
import os
import random
import re
import shutil
import subprocess
import struct
import tempfile
import tkinter as tk
import sv_ttk
import xml.etree.ElementTree as ET
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from PIL import Image, ImageDraw, ImageFont
from pydub import AudioSegment
from pydub.exceptions import CouldntDecodeError
from tkinter import ttk, messagebox

selected_songs = set()
selected_song_ids = []

# Function to load configuration from file
def load_config():
    config_file = "config.json"
    default_config = {
        #"max_concurrent": 5,  # Default values if not specified in config file
        "lang": "en",
        "audio_quality": "high",
        "texture_quality": "high",
        "custom_songs": False,
        "custom_song_path": "data_custom/"    
    }

    try:
        with open(config_file, "r") as f:
            config = json.load(f)
            # Override default values with values from config file
            default_config.update(config)
    except FileNotFoundError:
        print(f"Config file '{config_file}' not found. Using default configuration.")

    return default_config

data_dir = "data/"
musicinfo_path = os.path.join(data_dir, "datatable", "musicinfo.json")
wordlist_path = os.path.join(data_dir, "datatable", "wordlist.json")
previewpos_path = os.path.join(data_dir, "datatable", "previewpos.json")

# Load configuration
config = load_config()

custom_songs = config["custom_songs"]
lang = config["lang"]
audio_quality = config["audio_quality"]
texture_quality = config["texture_quality"]

if custom_songs == True:
    print("Custom Song Loading Enabled")
    custom_data_dir = config.get('custom_song_path')
    custom_musicinfo_path = os.path.join(custom_data_dir, "datatable", "musicinfo.json")
    custom_wordlist_path = os.path.join(custom_data_dir, "datatable", "wordlist.json")
    custom_previewpos_path = os.path.join(custom_data_dir, "datatable", "previewpos.json")

item_selection_state = {}

with open(musicinfo_path, "r", encoding="utf-8") as musicinfo_file:
    music_info = json.load(musicinfo_file)

with open(wordlist_path, "r", encoding="utf-8") as wordlist_file:
    word_list = json.load(wordlist_file)

if custom_songs == True:
    with open(custom_musicinfo_path, "r", encoding="utf-8") as custom_musicinfo_file:
        custom_music_info = json.load(custom_musicinfo_file)

    with open(custom_wordlist_path, "r", encoding="utf-8") as custom_wordlist_file:
        custom_word_list = json.load(custom_wordlist_file)

if lang == "jp":
    genre_map = {
        0: ("ポップス", "#219fbb"),
        1: ("アニメ", "#ff9700"),
        2: ("ボーカロイド", "#a2c4c8"),
        3: ("バラエティ", "#8fd321"),
        4: ("Unused", "#000000"),
        5: ("クラシック", "#d1a016"),
        6: ("ゲームミュージック", "#9c72c0"),
        7: ("ナムコオリジナル", "#ff5716"),
    }
else:
    genre_map = {
        0: ("Pop", "#219fbb"),
        1: ("Anime", "#ff9700"),
        2: ("Vocaloid", "#a2c4c8"),
        3: ("Variety", "#8fd321"),
        4: ("Unused (Kids)", "#000000"),
        5: ("Classic", "#d1a016"),
        6: ("Game Music", "#9c72c0"),
        7: ("Namco Original", "#ff5716"),
    } 

if lang == "jp":
    song_titles = {item["key"]: item["japaneseText"] for item in word_list["items"]}
    song_subtitles = {item["key"]: item["japaneseText"] for item in word_list["items"]}
else:
    song_titles = {item["key"]: item["englishUsText"] for item in word_list["items"]}
    song_subtitles = {item["key"]: item["englishUsText"] for item in word_list["items"]}

if custom_songs == True:
    if lang == "jp":
        custom_song_titles = {item["key"]: item["japaneseText"] for item in custom_word_list["items"]}
        custom_song_subtitles = {item["key"]: item["japaneseText"] for item in custom_word_list["items"]}
    else:
        custom_song_titles = {item["key"]: item["englishUsText"] for item in custom_word_list["items"]}
        custom_song_subtitles = {item["key"]: item["englishUsText"] for item in custom_word_list["items"]}

window = tk.Tk()
window.title("Taiko no Tatsujin Song Conversion GUI Tool")

window.iconbitmap('gui.ico')

# Set the initial size of the window
window.geometry("1400x800")  # Width x Height

# Create a new style for Treeview with grid lines
style = ttk.Style()
style.configure("Treeview", rowheight=25, borderwidth=1)
style.layout("Treeview", [('Treeview.treearea', {'sticky': 'nswe'})])

# Use the new style for the Treeview
style.configure("Treeview.Heading", background="lightgrey", foreground="black", borderwidth=1)
style.map("Treeview.Heading", background=[('active', 'grey')])

sv_ttk.set_theme("dark")

# Create a frame to contain the Treeview and scrollbar
main_frame = ttk.Frame(window)
main_frame.pack(fill="both", expand=True, padx=10, pady=10)

# Create Treeview and Scrollbar
tree = ttk.Treeview(main_frame, columns=("Select", "ID", "Song Name", "Song Subtitle", "Genre", "Difficulty"), show="headings", selectmode="extended")
if lang == "jp":
    tree.heading("Song Name", text="曲")
    tree.heading("Song Subtitle", text="曲名")
    tree.heading("Genre", text="ジャンル順")
    tree.heading("Difficulty", text="むずかしさ")
    tree.heading("Select", text="移動")
else:
    tree.heading("Song Name", text="Song Name")
    tree.heading("Song Subtitle", text="Song Subtitle")
    tree.heading("Genre", text="Genre")
    tree.heading("Difficulty", text="Difficulty")
    tree.heading("Select", text="Select")
tree.heading("ID", text="ID")


tree.column("Select", width=20, anchor=tk.CENTER)
tree.column("ID", width=60, anchor=tk.W)
tree.column("Song Name", anchor=tk.W)
tree.column("Song Subtitle", anchor=tk.W)
tree.column("Genre",  width=100, anchor=tk.W)
tree.column("Difficulty", width=120, anchor=tk.W)

vsb = ttk.Scrollbar(main_frame, orient="vertical", command=tree.yview)
tree.configure(yscrollcommand=vsb.set)

# Pack Treeview and Scrollbar into the main_frame
tree.pack(side="left", fill="both", expand=True)
vsb.pack(side="right", fill="y")

# Counter for selected items
selection_count = tk.IntVar()
selection_count.set(0)  # Initial selection count

def on_search_keyrelease(event):
    print("Key released:", event.keysym)
    #filter_treeview()

# Search Entry
if lang == "jp":
    search_label = tk.Label(window, text="フィルター曲：", anchor="w")
else:
    search_label = tk.Label(window, text="Filter Songs:", anchor="w")
search_label.pack(side="top", padx=20, pady=0, anchor="w")
search_var = tk.StringVar()
search_entry = ttk.Entry(window, textvariable=search_var)
search_entry.pack(side="bottom", fill="x", padx=10, pady=10)

def toggle_checkbox(event):
    selected_items = tree.selection()
    platform = game_platform_var.get()

    for item_id in selected_items:
        values = list(tree.item(item_id, "values"))
        song_id = values[1]  # Ensure this points to the correct column for song ID

        # Retrieve the song data to check the starUra value
        song = next((song for song in music_info["items"] if str(song["id"]) == song_id), None)
        if custom_songs and not song:
            song = next((song for song in custom_music_info["items"] if str(song["id"]) == song_id), None)

        star_ura = song.get("starUra", 0) if song else 0
        increment = 1

        if platform == "WIIU3" and star_ura > 0:
            increment = 2

        if values[0] == "☐":
            values[0] = "☑"
            if song_id not in selected_song_ids:
                selected_song_ids.append(song_id)
                selection_count.set(selection_count.get() + increment)
        else:
            values[0] = "☐"
            if song_id in selected_song_ids:
                selected_song_ids.remove(song_id)
                selection_count.set(selection_count.get() - increment)

        tree.item(item_id, values=values)

    update_selection_count()
    return "break"

def filter_treeview():
    search_text = search_var.get().strip().lower()
    populate_tree(search_text)  # Populate Treeview with filtered data
    
def populate_tree(search_text=""):
    # Clear existing items in the Treeview
    tree.delete(*tree.get_children())

    def add_song_to_tree(song, title_dict, subtitle_dict):
        song_id = f"{song['id']}"
        genre_no = song["genreNo"]
        genre_name, genre_color = genre_map.get(genre_no, ("Unknown Genre", "white"))
        english_title = title_dict.get(f"song_{song_id}", "-")
        english_subtitle = subtitle_dict.get(f"song_sub_{song_id}", "-")

        star_easy = song.get("starEasy", "N/A")
        star_normal = song.get("starNormal", "N/A")
        star_hard = song.get("starHard", "N/A")
        star_mania = song.get("starMania", "N/A")
        star_ura = song.get("starUra", 0)

        difficulty_info_parts = [
            f"★{star_easy}",
            f"★{star_normal}",
            f"★{star_hard}",
            f"★{star_mania}",
        ]

        if star_ura > 0:
            difficulty_info_parts.append(f"★{star_ura}")

        difficulty_info = " | ".join(difficulty_info_parts)

        # Check if the search text matches the song name
        if search_text in english_title.lower():
            values = ["☐", song_id, english_title, english_subtitle, genre_name, difficulty_info]
            if song_id in selected_song_ids:
                values[0] = "☑"
            item_id = tree.insert("", "end", values=values, tags=(genre_name,))
            tree.tag_configure(genre_name, background=genre_color)
            # Re-select item if it was previously selected
            if song_id in selected_song_ids:
                tree.selection_add(item_id)

    for song in sorted(music_info["items"], key=lambda x: x["id"]):  # Sort by ID
        add_song_to_tree(song, song_titles, song_subtitles)

    if custom_songs:
        for song in sorted(custom_music_info["items"], key=lambda x: x["id"]):  # Sort by ID
            add_song_to_tree(song, custom_song_titles, custom_song_subtitles)

search_entry.bind("<KeyRelease>", lambda event: filter_treeview())

def sort_tree(sort_option):
    # Clear existing items in the Treeview
    tree.delete(*tree.get_children())

    def add_sorted_songs(sorted_songs, title_dict, subtitle_dict):
        for song in sorted_songs:
            song_id = f"{song['id']}"
            genre_no = song["genreNo"]
            genre_name, genre_color = genre_map.get(genre_no, ("Unknown Genre", "white"))
            english_title = title_dict.get(f"song_{song_id}", "-")
            english_subtitle = subtitle_dict.get(f"song_sub_{song_id}", "-")

            star_easy = song.get("starEasy", "N/A")
            star_normal = song.get("starNormal", "N/A")
            star_hard = song.get("starHard", "N/A")
            star_mania = song.get("starMania", "N/A")
            star_ura = song.get("starUra", 0)

            difficulty_info_parts = [
                f"★{star_easy}",
                f"★{star_normal}",
                f"★{star_hard}",
                f"★{star_mania}",
            ]

            if star_ura > 0:
                difficulty_info_parts.append(f"★{star_ura}")

            difficulty_info = " | ".join(difficulty_info_parts)

            values = ["☐", song_id, english_title, english_subtitle, genre_name, difficulty_info]
            if song_id in selected_song_ids:
                values[0] = "☑"
            item_id = tree.insert("", "end", values=values, tags=(genre_name,))
            tree.tag_configure(genre_name, background=genre_color)
            # Re-select item if it was previously selected
            if song_id in selected_song_ids:
                tree.selection_add(item_id)

    if sort_option == "ID":
        sorted_songs = sorted(music_info["items"], key=lambda x: x["id"])
        add_sorted_songs(sorted_songs, song_titles, song_subtitles)
        if custom_songs:
            sorted_custom_songs = sorted(custom_music_info["items"], key=lambda x: x["id"])
            add_sorted_songs(sorted_custom_songs, custom_song_titles, custom_song_subtitles)
    elif sort_option == "Song Name":
        sorted_songs = sorted(music_info["items"], key=lambda x: song_titles.get(f"song_{x['id']}", "-"))
        add_sorted_songs(sorted_songs, song_titles, song_subtitles)
        if custom_songs:
            sorted_custom_songs = sorted(custom_music_info["items"], key=lambda x: custom_song_titles.get(f"song_{x['id']}", "-"))
            add_sorted_songs(sorted_custom_songs, custom_song_titles, custom_song_subtitles)
    elif sort_option == "Genre":
        for genre_no in sorted(genre_map.keys()):
            sorted_songs = [song for song in music_info["items"] if song["genreNo"] == genre_no]
            add_sorted_songs(sorted_songs, song_titles, song_subtitles)
            if custom_songs:
                sorted_custom_songs = [song for song in custom_music_info["items"] if song["genreNo"] == genre_no]
                add_sorted_songs(sorted_custom_songs, custom_song_titles, custom_song_subtitles)

def populate_song_entry(song):
    #unique_id = ""
    song_id = f"{song['id']}"
    genre_no = song["genreNo"]
    genre_name, genre_color = genre_map.get(genre_no, ("Unknown Genre", "white"))
    english_title = song_titles.get(f"song_{song_id}", "-")
    english_subtitle = song_subtitles.get(f"song_sub_{song_id}", "-")
    if custom_songs == True:
        english_title = custom_song_titles.get(f"song_{song_id}", "-")
        english_subtitle = custom_song_subtitles.get(f"song_sub_{song_id}", "-")        

    star_easy = song.get("starEasy", "N/A")
    star_normal = song.get("starNormal", "N/A")
    star_hard = song.get("starHard", "N/A")
    star_mania = song.get("starMania", "N/A")
    star_ura = song.get("starUra", 0)

    difficulty_info_parts = [
        f"{star_easy}",
        f"{star_normal}",
        f"{star_hard}",
        f"{star_mania}",
    ]

    if star_ura > 0:
        difficulty_info_parts.append(f"{star_ura}")

    difficulty_info = " | ".join(difficulty_info_parts)

    tree.insert("", "end", values=("☐", song_id, english_title, english_subtitle, genre_name, difficulty_info))
    tree.tag_configure(genre_name, background=genre_color)

# Populate the Treeview initially
populate_tree()

def update_selection_count(event=None):
    selected_items = tree.selection()
    count_selected = selection_count.get()  # Retrieve the value of selection_count

    platform = game_platform_var.get()
    if platform == "PS4":
        max_entries = 400
    elif platform == "WIIU3":
        if texture_quality == "low":
            max_entries = 460
        else:
            max_entries = 260
    elif platform == "NS1":
        max_entries = 600
    elif platform == "PTB":
        max_entries = 200
    else:
        max_entries = 0

    if len(selected_items) > max_entries:
        messagebox.showerror("Selection Limit Exceeded", f"Maximum {max_entries} entries can be selected for {platform}.")
    else:
        # Update the selection count label text
        selection_count_label.config(text=f"{count_selected}/{max_entries}")

def clear_selection():
    # Get all items in the treeview
    all_items = tree.get_children()

    for item_id in all_items:
        values = list(tree.item(item_id, "values"))
        song_id = values[1]  # Ensure this points to the correct column for song ID

        if values[0] == "☑":
            values[0] = "☐"
            tree.item(item_id, values=values)

    # Clear the selected song IDs and reset the selection count
    selected_song_ids.clear()
    selection_count.set(0)

    # Update the selection count display
    update_selection_count()

tree.bind("<ButtonRelease-1>", toggle_checkbox)

def preview_audio(song_id):
    preview_pos = get_preview_pos(song_id)
    if preview_pos is not None:
        song_filename = os.path.join(data_dir, "sound", f"song_{song_id}.mp3")
        subprocess.run(["ffplay", "-autoexit", "-ss", f"{preview_pos / 1000}", song_filename])

    if custom_songs:
        custom_preview_pos = get_preview_pos(song_id)
        if custom_preview_pos is not None:
            custom_song_filename = os.path.join(custom_data_dir, "sound", f"song_{song_id}.mp3")
            subprocess.run(["ffplay", "-autoexit", "-ss", f"{custom_preview_pos / 1000}", custom_song_filename])

def get_preview_pos(song_id):
    with open(previewpos_path, "r", encoding="utf-8") as previewpos_file:
        previewpos_data = json.load(previewpos_file)
        for item in previewpos_data:
            if item["id"] == song_id:
                return item["previewPos"]
    
    if custom_songs:
        with open(custom_previewpos_path, "r", encoding="utf-8") as custom_previewpos_file:
            custom_previewpos_data = json.load(custom_previewpos_file)
            for item in custom_previewpos_data:
                if item["id"] == song_id:
                    return item["previewPos"]
    return None

def preview_selected():
    selected_item = tree.selection()
    if selected_item:
        song_id = tree.item(selected_item[0])["values"][1]  # Ensure this points to the correct column for song ID
        preview_audio(song_id)

def merge_ptb(file1_path, file2_path, output_path):
    # Load the contents of the first wordlist file
    with open(file1_path, 'r', encoding='utf-8') as file1:
        data1 = json.load(file1)

    # Load the contents of the second wordlist file
    with open(file2_path, 'r', encoding='utf-8') as file2:
        data2 = json.load(file2)

    # Filter out entries from file 1 where key starts with "song_"
    filtered_items = [item for item in data1['items'] if not item['key'].startswith('song_')]

    # Update entries from file 2 and add them to the filtered list
    for item2 in data2['items']:
        # Set englishUsFontType to 3
        item2['englishUsFontType'] = 3

        # Add missing translation fields using englishUsText from file 2
        languages = ['french', 'italian', 'german', 'spanish', 'chineseT', 'korean',
                     'portuguese', 'russian', 'turkish', 'arabic', 'dutch', 'chineseS']
        for lang in languages:
            if lang + 'Text' not in item2:
                item2[lang + 'Text'] = item2['englishUsText']
                item2[lang + 'FontType'] = 3

        # Add updated item from file 2 to the filtered list
        filtered_items.append(item2)

    # Update data1 with the merged and filtered items
    data1['items'] = filtered_items

    # Save the updated JSON back to file
    with open(output_path, 'w', encoding='utf-8') as output_file:
        json.dump(data1, output_file, indent=4, ensure_ascii=False)

    print(f"Merged wordlists saved to '{output_path}'.")

def encrypt_file_ptb_audio(input_file, output_file, key, iv):
    with open(input_file, 'rb') as f_in:
        data = f_in.read()

    backend = default_backend()
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
    encryptor = cipher.encryptor()
    padded_data = data + b'\0' * (16 - len(data) % 16)  # Pad the data to make it a multiple of block size
    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()

    # Write IV followed by encrypted data to output file
    with open(output_file, 'wb') as f_out:
        f_out.write(iv)
        f_out.write(encrypted_data)

# audio conversion stuff(ptb)
def create_and_encrypt_acb(input_audio, song_id):
    # Generate a unique random temporary folder name
    with tempfile.TemporaryDirectory(prefix='song_') as temp_folder:
        try:
            # Convert input audio to 44100Hz WAV
            temp_wav_file = os.path.join(temp_folder, f'input_{song_id}.wav')

            audio = AudioSegment.from_file(input_audio)
            audio = audio.set_frame_rate(44100)
            audio.export(temp_wav_file, format='wav')

            # Generate .hca file using VGAudioCli.exe
            hca_folder = os.path.join(temp_folder, f'song_{song_id}')
            os.makedirs(hca_folder, exist_ok=True)
            hca_file = os.path.join(hca_folder, '00000.hca')
            subprocess.run(['data/_resource/executable/VGAudioCli.exe', temp_wav_file, hca_file], check=True)

            # Copy sample .acb template to temporary location
            acb_template = 'data/_resource/templates/song_sample.acb'
            temp_acb_file = os.path.join(temp_folder, f'song_{song_id}.acb')
            shutil.copy(acb_template, temp_acb_file)

            # Edit .acb using ACBEditor
            subprocess.run(['data/_resource/executable/ACBEditor.exe', hca_folder], check=True)

            # Encrypt .acb file to .bin with IV prepended
            key = bytes.fromhex('54704643596B474170554B6D487A597A')
            iv = bytes([0xFF] * 16)
            encrypted_bin_file = os.path.join(temp_folder, f'song_{song_id}.bin')
            encrypt_file_ptb_audio(temp_acb_file, encrypted_bin_file, key, iv)

            # Move encrypted .bin file to the root folder
            final_bin_file = f'song_{song_id}.bin'
            shutil.move(encrypted_bin_file, final_bin_file)

        except Exception as e:
            print(f"Error: {e}")

def merge_ps4_int(file1_path, file2_path, output_path):
    # Load the contents of the first wordlist file
    with open(file1_path, 'r', encoding='utf-8') as file1:
        data1 = json.load(file1)

    # Load the contents of the second wordlist file
    with open(file2_path, 'r', encoding='utf-8') as file2:
        data2 = json.load(file2)

    # Define keys to remove from data1, for space saving reasons. (sorry south americans)
    keys_to_remove_data1 = ["neutralSpanishText","neutralSpanishFontType","brazilPortugueseText","brazilPortugueseFontType"]

    # Filter out entries from file 1 where key starts with "song_" and remove specific keys
    filtered_items_data1 = []
    for item in data1['items']:
        if not item['key'].startswith('song_'):
            # Remove specific keys from item
            filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data1}
            #filtered_items = [item for item in data1['items'] if not item['key'].startswith('song_')]
            filtered_items_data1.append(filtered_item)

    # Define keys to remove from data2
    keys_to_remove_data2 = ["japaneseText", "japaneseFontType", "chineseTText","chineseTFontType","koreanText","koreanFontType"]

    # Filter out specific keys from entries in file 2
    filtered_items_data2 = []
    for item in data2['items']:
        # Remove specific keys from item
        filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data2}
        filtered_items_data2.append(filtered_item)

    # Extend filtered data1 with filtered data2
    filtered_items_data1.extend(filtered_items_data2)

    # Update data1 with the merged and filtered items
    data1['items'] = filtered_items_data1

    # Save the updated JSON back to file
    with open(output_path, 'w', encoding='utf-8') as output_file:
        json.dump(data1, output_file, indent=4, ensure_ascii=False)

    print(f"Merged wordlists saved to '{output_path}'.")

def merge_ps4_jp(file1_path, file2_path, output_path):
    # Load the contents of the first wordlist file
    with open(file1_path, 'r', encoding='utf-8') as file1:
        data1 = json.load(file1)

    # Load the contents of the second wordlist file
    with open(file2_path, 'r', encoding='utf-8') as file2:
        data2 = json.load(file2)

    # Define keys to remove from data1
    keys_to_remove_data1 = ["frenchText", "frenchFontType", "italianText", "italianFontType", "germanText", "germanFontType", "spanishText", "spanishFontType","neutralSpanishText","neutralSpanishFontType","brazilPortugueseText","brazilPortugueseFontType"]

    # Filter out entries from file 1 where key starts with "song_" and remove specific keys
    filtered_items_data1 = []
    for item in data1['items']:
        if not item['key'].startswith('song_'):
            # Remove specific keys from item
            filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data1}
            filtered_items_data1.append(filtered_item)

    # Define keys to remove from data2
    keys_to_remove_data2 = [""]

    # Filter out specific keys from entries in file 2
    filtered_items_data2 = []
    for item in data2['items']:
        # Remove specific keys from item
        filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data2}
        filtered_items_data2.append(filtered_item)

    # Extend filtered data1 with filtered data2
    filtered_items_data1.extend(filtered_items_data2)

    # Update data1 with the merged and filtered items
    data1['items'] = filtered_items_data1

    # Save the updated JSON back to file
    with open(output_path, 'w', encoding='utf-8') as output_file:
        json.dump(data1, output_file, indent=4, ensure_ascii=False)

    print(f"Merged wordlists saved to '{output_path}'.")

def merge_ns1_int(file1_path, file2_path, output_path):
    # Load the contents of the first wordlist file
    with open(file1_path, 'r', encoding='utf-8') as file1:
        data1 = json.load(file1)

    # Load the contents of the second wordlist file
    with open(file2_path, 'r', encoding='utf-8') as file2:
        data2 = json.load(file2)

    # Define keys to remove from data1
    keys_to_remove_data1 = ["japaneseText", "chineseTText","chineseTFontType","koreanText","koreanFontType"]

    # Filter out entries from file 1 where key starts with "song_" and remove specific keys
    filtered_items_data1 = []
    for item in data1['items']:
        if not item['key'].startswith('song_'):
            # Remove specific keys from item
            filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data1}
            filtered_items_data1.append(filtered_item)
    
# Define keys to remove from data2
    keys_to_remove_data2 = ["japaneseText", "japaneseFontType", "chineseTText","chineseTFontType","koreanText","koreanFontType"]

    for item2 in data2['items']:
        # Set englishUsFontType to 3
        item2['englishUsFontType'] = 0

        # Add missing translation fields using englishUsText from file 2
        languages = ['french', 'italian', 'german', 'spanish']
        for lang in languages:
            if lang + 'Text' not in item2:
                item2[lang + 'Text'] = item2['englishUsText']
                item2[lang + 'FontType'] = 3

    for item3 in data2['items']:
        if not item3['key'].startswith('song_detail_'):
            item3['englishUsFontType'] = 3
            
    # Filter out specific keys from entries in file 2
    filtered_items_data2 = []
    for item in data2['items']:
        # Remove specific keys from item
        filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data2}
        filtered_items_data2.append(filtered_item)

    # Extend filtered data1 with filtered data2
    filtered_items_data1.extend(filtered_items_data2)

    # Update data1 with the merged and filtered items
    data1['items'] = filtered_items_data1

    # Save the updated JSON back to file
    with open(output_path, 'w', encoding='utf-8') as output_file:
        json.dump(data1, output_file, indent=4, ensure_ascii=False)

    print(f"Merged wordlists saved to '{output_path}'.")

def merge_ns1_jp(file1_path, file2_path, output_path):
    # Load the contents of the first wordlist file
    with open(file1_path, 'r', encoding='utf-8') as file1:
        data1 = json.load(file1)

    # Load the contents of the second wordlist file
    with open(file2_path, 'r', encoding='utf-8') as file2:
        data2 = json.load(file2)

    # Define keys to remove from data1
    keys_to_remove_data1 = ["frenchText", "frenchFontType", "italianText", "italianFontType", "germanText", "germanFontType", "spanishText", "spanishFontType"]

    # Filter out entries from file 1 where key starts with "song_" and remove specific keys
    filtered_items_data1 = []
    for item in data1['items']:
        if not item['key'].startswith('song_'):
            # Remove specific keys from item
            filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data1}
            filtered_items_data1.append(filtered_item)
    
    # Define keys to remove from data2
    keys_to_remove_data2 = ["japaneseFontType"]

    for item2 in data2['items']:
        # Set englishUsFontType to 3
        item2['englishUsFontType'] = 0

    for item3 in data2['items']:
        if not item3['key'].startswith('song_detail_'):
            item3['englishUsFontType'] = 3
            
    # Filter out specific keys from entries in file 2
    filtered_items_data2 = []
    for item in data2['items']:
        # Remove specific keys from item
        filtered_item = {k: v for k, v in item.items() if k not in keys_to_remove_data2}
        filtered_items_data2.append(filtered_item)

    # Extend filtered data1 with filtered data2
    filtered_items_data1.extend(filtered_items_data2)

    # Update data1 with the merged and filtered items
    data1['items'] = filtered_items_data1

    # Save the updated JSON back to file
    with open(output_path, 'w', encoding='utf-8') as output_file:
        json.dump(data1, output_file, indent=4, ensure_ascii=False)

    print(f"Merged wordlists saved to '{output_path}'.")

# audio conversion stuff(ns1/ps4)
#from idsp.py
def convert_audio_to_idsp(input_file, output_file):
    temp_folder = tempfile.mkdtemp()
    try:
        if not input_file.lower().endswith('.wav'):
            temp_wav_file = os.path.join(temp_folder, "temp.wav")
            audio = AudioSegment.from_file(input_file)
            audio.export(temp_wav_file, format="wav")
            input_file = temp_wav_file

        vgaudio_cli_path = os.path.join("data/_resource/executable", "VGAudioCli.exe")
        subprocess.run([vgaudio_cli_path, "-i", input_file, "-o", output_file], check=True)
    finally:
        shutil.rmtree(temp_folder, ignore_errors=True)

#from lopus.py
def convert_audio_to_opus(input_file, output_file):
    # Create a unique temporary folder to store intermediate files
    temp_folder = tempfile.mkdtemp()

    try:
        # Check if the input file is already in WAV format
        if not input_file.lower().endswith('.wav'):
            # Load the input audio file using pydub and convert to WAV
            temp_wav_file = os.path.join(temp_folder, "temp.wav")
            audio = AudioSegment.from_file(input_file)
            audio = audio.set_frame_rate(48000)  # Set frame rate to 48000 Hz
            audio.export(temp_wav_file, format="wav")
            input_file = temp_wav_file

        # Path to VGAudioCli executable
        vgaudio_cli_path = os.path.join("data/_resource/executable", "VGAudioCli.exe")

        # Run VGAudioCli to convert WAV to Switch OPUS
        subprocess.run([vgaudio_cli_path, "-i", input_file, "-o", output_file, "--opusheader", "namco"], check=True)

    finally:
        # Clean up temporary folder
        shutil.rmtree(temp_folder, ignore_errors=True)

#from wav.py
def convert_audio_to_wav(input_file, output_file):
    try:
        # Load the input audio file using pydub
        audio = AudioSegment.from_file(input_file)

        # Ensure the output file has a .wav extension
        if not output_file.lower().endswith('.wav'):
            output_file += '.wav'

        # Export the audio to WAV format
        audio.export(output_file, format="wav")

    except Exception as e:
        raise RuntimeError(f"Error during WAV conversion: {e}")

#from at9.py
def convert_audio_to_at9(input_file, output_file):
    # Create a unique temporary folder to store intermediate files
    temp_folder = tempfile.mkdtemp()
    
    try:
        # Check if the input file is already in WAV format
        if not input_file.lower().endswith('.wav'):
            # Load the input audio file using pydub and convert to WAV
            temp_wav_file = os.path.join(temp_folder, "temp.wav")
            audio = AudioSegment.from_file(input_file)
            audio.export(temp_wav_file, format="wav")
            input_file = temp_wav_file

        # Path to AT9Tool executable
        at9tool_cli_path = os.path.join("data/_resource/executable", "at9tool.exe")

        # Run VGAudioCli to convert WAV to AT9
        subprocess.run([at9tool_cli_path, "-e", "-br", "192", input_file, output_file], check=True)

    finally:
        # Clean up temporary folder
        shutil.rmtree(temp_folder, ignore_errors=True)

# from bnsf.py
def convert_to_mono_48k(input_file, output_file):
    """Convert input audio file to 16-bit mono WAV with 48000 Hz sample rate."""
    try:
        audio = AudioSegment.from_file(input_file)
        audio = audio.set_channels(1)  # Convert to mono
        audio = audio.set_frame_rate(48000)  # Set frame rate to 48000 Hz
        audio = audio.set_sample_width(2)  # Set sample width to 16-bit (2 bytes)
        audio.export(output_file, format='wav')
    except CouldntDecodeError:
        print(f"Error: Unable to decode {input_file}. Please provide a valid audio file.")
        #sys.exit(1)

def run_encode_tool(input_wav, output_bs):
    """Run external encode tool with specified arguments."""
    subprocess.run(['data/_resource/executable/encode.exe', '0', input_wav, output_bs, '48000', '14000'])

def modify_bnsf_template(output_bs, output_bnsf, header_size, total_samples):
    """Modify the BNSF template file with calculated values and combine with output.bs."""
    # Calculate the file size of output.bs
    bs_file_size = os.path.getsize(output_bs)

    # Create modified BNSF data
    new_file_size = bs_file_size + header_size - 0x8
    total_samples_bytes = total_samples.to_bytes(4, 'big')
    bs_file_size_bytes = bs_file_size.to_bytes(4, 'big')
    
    # Read BNSF template data
    with open('data/_resource/templates/header.bnsf', 'rb') as template_file:
        bnsf_template_data = bytearray(template_file.read())

    # Modify BNSF template with calculated values
    bnsf_template_data[0x4:0x8] = new_file_size.to_bytes(4, 'big')  # File size
    bnsf_template_data[0x1C:0x20] = total_samples_bytes  # Total sample count
    bnsf_template_data[0x2C:0x30] = bs_file_size_bytes  # Size of output.bs

    # Append output.bs data to modified BNSF template
    with open(output_bs, 'rb') as bs_file:
        bs_data = bs_file.read()
        final_bnsf_data = bnsf_template_data + bs_data

    # Write final BNSF file
    with open(output_bnsf, 'wb') as output_file:
        output_file.write(final_bnsf_data)

#from nus3.py
def generate_random_uint16_hex():
    return format(random.randint(0, 65535), '04X')

def select_template_name(game, output_file):
    base_filename = os.path.splitext(output_file)[0]
    length = len(base_filename)

    if game == "nijiiro":
        if length == 8:
            return "song_ABC"
        elif length == 9:
            return "song_ABCD"
        elif length == 10:
            return "song_ABCDE"
        elif length == 11:
            return "song_ABCDEF"
        elif length == 12:
            return "song_ABCDEFG"    
        elif length == 13:
            return "song_ABCDEFGH"
    elif game == "ps4":
        if length == 8:
            return "song_ABC"
        elif length == 9:
            return "song_ABCD"
        elif length == 10:
            return "song_ABCDE"
        elif length == 11:
            return "song_ABCDEF"
    elif game == "ns1":
        if length == 8:
            return "song_ABC"
        elif length == 9:
            return "song_ABCD"
        elif length == 10:
            return "song_ABCDE"
        elif length == 11:
            return "song_ABCDEF"
    elif game == "wiiu3":
        if length == 8:
            return "song_ABC"
        elif length == 9:
            return "song_ABCD"
        elif length == 10:
            return "song_ABCDE"
        elif length == 11:
            return "song_ABCDEF"

    raise ValueError("Unsupported game or output file name length.")

def modify_nus3bank_template(game, template_name, audio_file, preview_point, output_file):
    game_templates = {        
        "nijiiro": {
            "template_folder": "nijiiro",
            "templates": {
                "song_ABC": {
                    "unique_id_offset": 176,
                    "audio_size_offsets": [76, 1568, 1852],
                    "preview_point_offset": 1724,
                    "song_placeholder": "song_ABC",
                    "template_file": "song_ABC.nus3bank"
                },
                "song_ABCD": {
                    "unique_id_offset": 176,
                    "audio_size_offsets": [76, 1568, 1852],
                    "preview_point_offset": 1724,
                    "song_placeholder": "song_ABCD",
                    "template_file": "song_ABCD.nus3bank"
                },
                "song_ABCDE": {
                    "unique_id_offset": 176,
                    "audio_size_offsets": [76, 1568, 1852],
                    "preview_point_offset": 1724,
                    "song_placeholder": "song_ABCDE",
                    "template_file": "song_ABCDE.nus3bank"
                },
                "song_ABCDEF": {
                    "unique_id_offset": 180,
                    "audio_size_offsets": [76, 1576, 1868],
                    "preview_point_offset": 1732,
                    "song_placeholder": "song_ABCDEF",
                    "template_file": "song_ABCDEF.nus3bank"
                },
                "song_ABCDEFG": {
                    "unique_id_offset": 180,
                    "audio_size_offsets": [76, 1672, 1964],
                    "preview_point_offset": 1824,
                    "song_placeholder": "song_ABCDEFG",
                    "template_file": "song_ABCDEFG.nus3bank"
                },
                "song_ABCDEFGH": {
                    "unique_id_offset": 180,
                    "audio_size_offsets": [76, 1576, 1868],
                    "preview_point_offset": 1732,
                    "song_placeholder": "song_ABCDEFGH",
                    "template_file": "song_ABCDEFGH.nus3bank"
                },            
            }
        },
        "ns1": {
            "template_folder": "ns1",
            "templates": {
                "song_ABC": {
                    "audio_size_offsets": [76, 5200, 5420],
                    "preview_point_offset": 5324,
                    "song_placeholder": "SONG_ABC",
                    "template_file": "SONG_ABC.nus3bank"
                },
                "song_ABCD": {
                    "audio_size_offsets": [76, 5200, 5420],
                    "preview_point_offset": 5324,
                    "song_placeholder": "SONG_ABCD",
                    "template_file": "SONG_ABCD.nus3bank"
                },
                "song_ABCDE": {
                    "audio_size_offsets": [76, 5200, 5404],
                    "preview_point_offset": 5320,
                    "song_placeholder": "SONG_ABCDE",
                    "template_file": "SONG_ABCDE.nus3bank"
                },
                "song_ABCDEF": {
                    "audio_size_offsets": [76, 5208, 5420],
                    "preview_point_offset": 5324,
                    "song_placeholder": "SONG_ABCDEF",
                    "template_file": "SONG_ABCDEF.nus3bank"
                }
            }
        },
        "ps4": {
            "template_folder": "ps4",
            "templates": {
                "song_ABC": {
                    "audio_size_offsets": [76, 3220, 3436],
                    "preview_point_offset": 3344,
                    "song_placeholder": "SONG_ABC",
                    "template_file": "SONG_ABC.nus3bank"
                },
                "song_ABCD": {
                    "audio_size_offsets": [76, 3220, 3436],
                    "preview_point_offset": 3344,
                    "song_placeholder": "SONG_ABCD",
                    "template_file": "SONG_ABCD.nus3bank"
                },
                "song_ABCDE": {
                    "audio_size_offsets": [76, 3220, 3436],
                    "preview_point_offset": 3344,
                    "song_placeholder": "SONG_ABCDE",
                    "template_file": "SONG_ABCDE.nus3bank"
                },
                "song_ABCDEF": {
                    "audio_size_offsets": [76, 3228, 3452],
                    "preview_point_offset": 3352,
                    "song_placeholder": "SONG_ABCDEF",
                    "template_file": "SONG_ABCDEF.nus3bank"
                }
            }
        },
        "wiiu3": {
            "template_folder": "wiiu3",
            "templates": {
                "song_ABC": {
                    "audio_size_offsets": [76, 3420, 3612],
                    "preview_point_offset": 3540,
                    "song_placeholder": "SONG_ABC",
                    "template_file": "SONG_ABC.nus3bank"
                },
                "song_ABCD": {
                    "audio_size_offsets": [76, 3420, 3612],
                    "preview_point_offset": 3540,
                    "song_placeholder": "SONG_ABCD",
                    "template_file": "SONG_ABCD.nus3bank"
                },
                "song_ABCDE": {
                    "audio_size_offsets": [76, 3420, 3612],
                    "preview_point_offset": 3540,
                    "song_placeholder": "SONG_ABCDE",
                    "template_file": "SONG_ABCDE.nus3bank"
                },
                "song_ABCDEF": {
                    "audio_size_offsets": [76, 3428, 3612],
                    "preview_point_offset": 3548,
                    "song_placeholder": "SONG_ABCDEF",
                    "template_file": "SONG_ABCDEF.nus3bank"
                }
            }
        },
    }

    if game not in game_templates:
        raise ValueError("Unsupported game.")

    templates_config = game_templates[game]

    if template_name not in templates_config["templates"]:
        raise ValueError(f"Unsupported template for {game}.")

    template_config = templates_config["templates"][template_name]
    template_folder = templates_config["template_folder"]

    # Read template nus3bank file from the specified game's template folder
    template_file = os.path.join("data/_resource/templates", template_folder, template_config['template_file'])
    with open(template_file, 'rb') as f:
        template_data = bytearray(f.read())

    # Set unique ID if it exists in the template configuration
    if 'unique_id_offset' in template_config:
        # Generate random UInt16 hex for unique ID
        unique_id_hex = generate_random_uint16_hex()
        # Set unique ID in the template data at the specified offset
        template_data[template_config['unique_id_offset']:template_config['unique_id_offset']+2] = bytes.fromhex(unique_id_hex)

    # Get size of the audio file in bytes
    audio_size = os.path.getsize(audio_file)

    # Convert audio size to UInt32 bytes in little-endian format
    size_bytes = audio_size.to_bytes(4, 'little')

    # Set audio size in the template data at the specified offsets
    for offset in template_config['audio_size_offsets']:
        template_data[offset:offset+4] = size_bytes

    # Convert preview point (milliseconds) to UInt32 bytes in little-endian format
    preview_point_ms = int(preview_point)
    preview_point_bytes = preview_point_ms.to_bytes(4, 'little')

    # Set preview point in the template data at the specified offset
    template_data[template_config['preview_point_offset']:template_config['preview_point_offset']+4] = preview_point_bytes

    # Replace song name placeholder with the output file name in bytes
    output_file_bytes = output_file.encode('utf-8')
    template_data = template_data.replace(template_config['song_placeholder'].encode('utf-8'), output_file_bytes.replace(b'.nus3bank', b''))

    # Append the audio file contents to the modified template data
    with open(audio_file, 'rb') as audio:
        template_data += audio.read()

    # Write the modified data to the output file
    with open(output_file, 'wb') as out:
        out.write(template_data)

    print(f"Created {output_file} successfully.")

def run_script(script_name, script_args):
    if script_name == "idsp":
        input_file, output_file = script_args
        convert_audio_to_idsp(input_file, output_file)
    elif script_name == "lopus":
        input_file, output_file = script_args
        convert_audio_to_opus(input_file, output_file)
    elif script_name == "at9":
        input_file, output_file = script_args
        convert_audio_to_at9(input_file, output_file)        
    elif script_name == "wav":
        input_file, output_file = script_args
        convert_audio_to_wav(input_file, output_file)              
    elif script_name == "bnsf":
        input_audio, output_bnsf = script_args
        temp_folder = 'temp'
        os.makedirs(temp_folder, exist_ok=True)
        output_wav = os.path.join(temp_folder, 'output_mono.wav')
        output_bs = os.path.join(temp_folder, 'output.bs')
        header_size = 0x30
        
        try:
            convert_to_mono_48k(input_audio, output_wav)
            run_encode_tool(output_wav, output_bs)
            mono_wav = AudioSegment.from_wav(output_wav)
            total_samples = len(mono_wav.get_array_of_samples())
            modify_bnsf_template(output_bs, output_bnsf, header_size, total_samples)
            print("BNSF file created:", output_bnsf)
        finally:
            if os.path.exists(temp_folder):
                shutil.rmtree(temp_folder)    
    elif script_name == "nus3":
        game, audio_file, preview_point, output_file = script_args
        template_name = select_template_name(game, output_file)
        modify_nus3bank_template(game, template_name, audio_file, preview_point, output_file)
    else:
        print(f"Unsupported script: {script_name}")
        #sys.exit(1)

def convert_audio_to_nus3bank(input_audio, audio_type, game, preview_point, song_id):
    output_filename = f"song_{song_id}.nus3bank"
    converted_audio_file = f"{input_audio}.{audio_type}"

    if audio_type in ["bnsf", "at9", "idsp", "lopus", "wav"]:
        try:
            run_script(audio_type, [input_audio, converted_audio_file])
            run_script("nus3", [game, converted_audio_file, preview_point, output_filename])
            print(f"Conversion successful! Created {output_filename}")

            if os.path.exists(converted_audio_file):
                os.remove(converted_audio_file)
                print(f"Deleted {converted_audio_file}")
        except subprocess.CalledProcessError as e:
            print(f"Error: {e}")
    else:
        print(f"Unsupported audio type: {audio_type}")

#wiiu3 texture gen
# Define a dictionary for vertical forms of certain punctuation marks
rotated_chars = {
    '「': '﹁', '」': '﹂',
    '『': '﹃', '』': '﹄',
    '（': '︵', '）': '︶',
    '［': '﹇', '］': '﹈',
    '〝': '﹁', '〟': '﹂',
    '｛': '︷', '｝': '︸',
    '｟': '︹', '｠': '︺',
    '＜': '︿', '＞': '﹀',
    '《': '︽', '》': '︾',
    '〈': '︿', '〉': '﹀',
    '【': '︻', '】': '︼',
    '〔': '︹', '〕': '︺',
    '「': '﹁', '」': '﹂',
    '『': '﹃', '』': '﹄',
    '（': '︵', '）': '︶',
    '［': '﹇', '］': '﹈',
    '｛': '︷', '｝': '︸',
    '〈': '︿', '〉': '﹀',
    '《': '︽', '》': '︾',
    '【': '︻', '】': '︼',
    '〔': '︹', '〕': '︺',
    '～': '｜', '～': '｜',
    '(': '︵', ')': '︶',
    '-':  'l'
}

rotated_letters = {
    'ー': '｜', '一': 'l'
}

full_width_chars = {
    'Ａ': 'A', 'Ｂ': 'B', 'Ｃ': 'C', 'Ｄ': 'D', 'Ｅ': 'E', 'Ｆ': 'F', 'Ｇ': 'G', 'Ｈ': 'H', 'Ｉ': 'I',
    'Ｊ': 'J', 'Ｋ': 'K', 'Ｌ': 'L', 'Ｍ': 'M', 'Ｎ': 'N', 'Ｏ': 'O', 'Ｐ': 'P', 'Ｑ': 'Q', 'Ｒ': 'R',
    'Ｓ': 'S', 'Ｔ': 'T', 'Ｕ': 'U', 'Ｖ': 'V', 'Ｗ': 'W', 'Ｘ': 'X', 'Ｙ': 'Y', 'Ｚ': 'Z',
    'ａ': 'a', 'ｂ': 'b', 'ｃ': 'c', 'ｄ': 'd', 'ｅ': 'e', 'ｆ': 'f', 'ｇ': 'g', 'ｈ': 'h', 'ｉ': 'i',
    'ｊ': 'j', 'ｋ': 'k', 'ｌ': 'l', 'ｍ': 'm', 'ｎ': 'n', 'ｏ': 'o', 'ｐ': 'p', 'ｑ': 'q', 'ｒ': 'r',
    'ｓ': 's', 'ｔ': 't', 'ｕ': 'u', 'ｖ': 'v', 'ｗ': 'w', 'ｘ': 'x', 'ｙ': 'y', 'ｚ': 'z'
}

def convert_full_width(text):
    converted_text = ''
    for char in text:
        converted_text += full_width_chars.get(char, char)
    return converted_text


def get_text_bbox(draw, text, font):
    return draw.textbbox((0, 0), text, font=font)

def generate_image(draw, text, font, rotated_font, size, position, alignment, stroke_width, stroke_fill, fill, vertical=False, vertical_small=False):
    width, height = size

    # Calculate initial text dimensions
    text_bbox = get_text_bbox(draw, text, font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    if vertical or vertical_small:
        text_height = 0
        max_char_width = 0
        for char in text:
            char_font = rotated_font if char in rotated_chars else font
            char = rotated_chars.get(char, char)
            char = rotated_letters.get(char, char)
            text_bbox = get_text_bbox(draw, char, char_font)
            text_height += text_bbox[3] - text_bbox[1]
            char_width = text_bbox[2] - text_bbox[0]
            if char_width > max_char_width:
                max_char_width = char_width

        text_height = max(0, text_height - 1)  # Remove the last extra space
        text_position = (position[0] - max_char_width / 2, (height - text_height) / 2)
    else:
        text_bbox = get_text_bbox(draw, text, font)
        text_width = text_bbox[2] - text_bbox[0]
        text_height = text_bbox[3] - text_bbox[1]

        if alignment == 'center':
            text_position = ((width - text_width) / 2, position[1])
        elif alignment == 'right':
            text_position = (width - text_width, position[1])
        else:
            text_position = position

    if vertical:
        y_offset = 5
        for char in text:
            char_font = rotated_font if char in rotated_chars else font
            char = rotated_chars.get(char, char)
            char = rotated_letters.get(char, char)
            text_bbox = get_text_bbox(draw, char, char_font)
            char_height = (text_bbox[3] + text_bbox[1])
            char_width = text_bbox[2] - text_bbox[0]
            draw.text((text_position[0] - char_width / 2, y_offset), char, font=char_font, fill=fill, stroke_width=stroke_width, stroke_fill=stroke_fill)
            y_offset += char_height
    elif vertical_small:
        y_offset = 5
        for char in text:
            char_font = rotated_font if char in rotated_chars else font
            char = rotated_chars.get(char, char)
            char = rotated_letters.get(char, char)
            text_bbox = get_text_bbox(draw, char, char_font)
            char_height = (text_bbox[3] + text_bbox[1])
            char_width = text_bbox[2] - text_bbox[0]
            draw.text((text_position[0] - char_width / 2, y_offset), char, font=char_font, fill=fill, stroke_width=stroke_width, stroke_fill=stroke_fill)
            y_offset += char_height            
    else:
        draw.text(text_position, text, font=font, fill=fill, stroke_width=stroke_width, stroke_fill=stroke_fill)

def create_images(data, id, genreNo, font_path, rotated_font_path, current_unique_id, append_ura=False):
    font_size_extra_large = 46.06875 
    font_size_large = 40.60875 
    font_size_medium = 27.3
    font_size_small = 21.84 

    img_3_5_height = 400
    formatted_id = f"{current_unique_id:04d}"
    texture_output_dir = f"out/content/{formatted_id}/texture"    

    folder_name = os.path.join(texture_output_dir, id)
    os.makedirs(folder_name, exist_ok=True)

    # Define genre colors
    genre_colors = [
        (0, 78, 88),    # pop
        (159, 61, 2),   # anime
        (90, 98, 129),  # vocaloid
        (55, 74, 0),    # variety        
        (0, 0, 0),      # unused (kids)
        (115, 77, 0),   # classic
        (82, 32, 115),  # game music
        (156, 36, 8),   # namco original
    ]

    genre_color = genre_colors[genreNo]

    # Initialize text variables
    japanese_text = ""
    japanese_sub_text = ""


    # Find the relevant texts
    for item in data['items']:
        if item['key'] == f'song_{id}':
            japanese_text = item['japaneseText']
        if item['key'] == f'song_sub_{id}':
            japanese_sub_text = item['japaneseText']

    # Convert full-width English characters to normal ASCII characters
    japanese_text = convert_full_width(japanese_text)
    japanese_sub_text = convert_full_width(japanese_sub_text) if japanese_sub_text else ''

    # Append "─" character if -ura argument is provided
    if append_ura:
        japanese_text += "─"

    padded_japanese_text = japanese_text + " "
    padded_japanese_sub_text = japanese_sub_text + " "

    # Check if texts were found
    if not japanese_text:
        print(f"Error: No Japanese text found for song_{id}")
        return
    if not japanese_sub_text:
        print(f"Warning: No Japanese sub text found for song_sub_{id}")

    font_extra_large = ImageFont.truetype(font_path, int(font_size_extra_large))
    font_large = ImageFont.truetype(font_path, int(font_size_large))
    font_medium = ImageFont.truetype(font_path, int(font_size_medium))
    font_small = ImageFont.truetype(font_path, int(font_size_small))
    rotated_font = ImageFont.truetype(rotated_font_path, int(font_size_medium))

    # Image 0.png
    img0_width = 720

    img0 = Image.new('RGBA', (img0_width, 64), color=(0, 0, 0, 0))
    draw0 = ImageDraw.Draw(img0)

    temp_img0 = Image.new('RGBA', (2880, 64), (0, 0, 0, 0))  # Temporary image with 2880px width
    temp_draw0 = ImageDraw.Draw(temp_img0)

    # Generate the image with the Japanese text
    generate_image(temp_draw0, padded_japanese_text, font_large, rotated_font, (2880, 64), (0, 10), 'right', 5, 'black', 'white')

    # Calculate the bounding box of the entire text
    text_bbox = get_text_bbox(temp_draw0, padded_japanese_text, font_large)
    text_width = (text_bbox[2] - text_bbox[0]) + 5

    # Resize the image if it exceeds the specified height
    if text_width > img0_width:
        cropped_img0 = temp_img0.crop((2880 - text_width, 0, 2880, 64))

        scaled_img0 = cropped_img0.resize((img0_width, 64), Image.Resampling.LANCZOS)

        final_img0 = Image.new('RGBA', (img0_width, 64), (0, 0, 0, 0))
        final_img0.paste(scaled_img0)
    else:
    # Crop the temporary image to the actual width of the text
        cropped_img0 = temp_img0.crop((2880 - text_width, 0, 2880, 64))
        final_img0 = Image.new('RGBA', (img0_width, 64), (0, 0, 0, 0))
        final_img0.paste(cropped_img0, (img0_width - text_width, 0))

    # Save the final image
    final_img0.save(os.path.join(folder_name, '0.png'))

    # Image 1.png
    img1_width = 720

    img1 = Image.new('RGBA', (img1_width, 104), color=(0, 0, 0, 0))
    draw1 = ImageDraw.Draw(img1)

    temp_img1 = Image.new('RGBA', (2880, 104), (0, 0, 0, 0))  # Temporary image with 2880px width
    temp_draw1 = ImageDraw.Draw(temp_img1)

    temp_sub_img1 = Image.new('RGBA', (2880, 104), (0, 0, 0, 0))  # Temporary image with 2880px width
    temp_sub_draw1 = ImageDraw.Draw(temp_sub_img1)

    # Generate the image with the Japanese text
    generate_image(temp_draw1, japanese_text, font_extra_large, rotated_font, (2880, 104), (0, 13), 'center', 5, 'black', 'white')

    # Calculate the bounding box of the entire text
    text_bbox = get_text_bbox(temp_draw1, japanese_text, font_extra_large)
    text_width = (text_bbox[2] - text_bbox[0]) + 5

    # Resize the image if it exceeds the specified width
    if text_width > img1_width:
        # Calculate the crop box to crop equally from both sides
        left_crop = (2880 - text_width) // 2
        right_crop = 2880 - left_crop
        cropped_img1 = temp_img1.crop((left_crop, 0, right_crop, 104))
        scaled_img1 = cropped_img1.resize((img1_width, 104), Image.Resampling.LANCZOS)
        img1_1 = Image.new('RGBA', (img1_width, 104), (0, 0, 0, 0))
        img1_1.paste(scaled_img1)
    else:
        # Crop the temporary image to the actual width of the text
        left_crop = (2880 - text_width) // 2
        right_crop = 2880 - left_crop
        cropped_img1 = temp_img1.crop((left_crop, 0, right_crop, 104))
        img1_1 = Image.new('RGBA', (img1_width, 104), (0, 0, 0, 0))
        offset = (img1_width - text_width) // 2
        img1_1.paste(cropped_img1, (offset, 0))

    # Generate the image with the Japanese sub-text
    generate_image(temp_sub_draw1, japanese_sub_text, font_medium, rotated_font, (2880, 104), (0, 68), 'center', 4, 'black', 'white')

    # Calculate the bounding box of the entire sub-text
    text_bbox_sub = get_text_bbox(temp_sub_draw1, japanese_sub_text, font_medium)
    text_width_sub = (text_bbox_sub[2] - text_bbox_sub[0]) + 5

    # Resize the sub-image if it exceeds the specified width
    if text_width_sub > img1_width:
        # Calculate the crop box to crop equally from both sides
        left_crop_sub = (2880 - text_width_sub) // 2
        right_crop_sub = 2880 - left_crop_sub
        cropped_img1_sub = temp_sub_img1.crop((left_crop_sub, 0, right_crop_sub, 104))
        scaled_img1_sub = cropped_img1_sub.resize((img1_width, 104), Image.Resampling.LANCZOS)
        img1_2 = Image.new('RGBA', (img1_width, 104), (0, 0, 0, 0))
        img1_2.paste(scaled_img1_sub)
    else:
        # Crop the temporary sub-image to the actual width of the sub-text
        left_crop_sub = (2880 - text_width_sub) // 2
        right_crop_sub = 2880 - left_crop_sub
        cropped_img1_sub = temp_sub_img1.crop((left_crop_sub, 0, right_crop_sub, 104))
        img1_2 = Image.new('RGBA', (img1_width, 104), (0, 0, 0, 0))
        offset_sub = (img1_width - text_width_sub) // 2
        img1_2.paste(cropped_img1_sub, (offset_sub, 0))

    final_img1 = Image.new('RGBA', (img1_width, 104), (0, 0, 0, 0))
    final_img1.paste(img1_1, (0, 0))
    final_img1.paste(img1_2, (0, 0), img1_2) 
    final_img1.save(os.path.join(folder_name, '1.png'))

    # Image 2.png
    img2_width = 720

    img2 = Image.new('RGBA', (img2_width, 64), color=(0, 0, 0, 0))
    draw2 = ImageDraw.Draw(img2)

    temp_img2 = Image.new('RGBA', (2880, 64), (0, 0, 0, 0))  # Temporary image with 2880px width
    temp_draw2 = ImageDraw.Draw(temp_img2)

    # Generate the image with the Japanese text
    generate_image(temp_draw2, japanese_text, font_large, rotated_font, (2880, 64), (0, 4), 'center', 5, 'black', 'white')

    # Calculate the bounding box of the entire text
    text_bbox = get_text_bbox(temp_draw2, japanese_text, font_large)
    text_width = (text_bbox[2] - text_bbox[0]) + 5

    # Resize the image if it exceeds the specified height
    if text_width > img2_width:
        # Calculate the crop box to crop equally from both sides
        left_crop = (2880 - text_width) // 2
        right_crop = 2880 - left_crop
        cropped_img2 = temp_img2.crop((left_crop, 0, right_crop, 64))

        scaled_img2 = cropped_img2.resize((img2_width, 64), Image.Resampling.LANCZOS)

        final_img2 = Image.new('RGBA', (img2_width, 64), (0, 0, 0, 0))
        final_img2.paste(scaled_img2)
    else:
    # Crop the temporary image to the actual width of the text
        left_crop = (2880 - text_width) // 2
        right_crop = 2880 - left_crop
        cropped_img2 = temp_img2.crop((left_crop, 0, right_crop, 64))
        final_img2 = Image.new('RGBA', (img2_width, 64), (0, 0, 0, 0))
        offset = (img2_width - text_width) // 2
        final_img2.paste(cropped_img2, (offset, 0))

    final_img2.save(os.path.join(folder_name, '2.png'))
    
    # Image 3.png    

    img3_height = 400

    img3 = Image.new('RGBA', (96, 400), color=(0, 0, 0, 0))
    img3_1 = Image.new('RGBA', (96, 400), color=(0, 0, 0, 0))
    img3_2 = Image.new('RGBA', (96, 400), color=(0, 0, 0, 0))
    draw3 = ImageDraw.Draw(img3)

    temp_img3 = Image.new('RGBA', (96, 3000), (0, 0, 0, 0))  # Temporary image with 1000px height
    temp_draw3 = ImageDraw.Draw(temp_img3)

    temp_sub_img3 = Image.new('RGBA', (96, 3000), (0, 0, 0, 0))  # Temporary image with 1000px height
    temp_sub_draw3 = ImageDraw.Draw(temp_sub_img3)

    generate_image(temp_draw3, padded_japanese_text, font_large, rotated_font, (96, 3000), (89, 0), 'center', 5, 'black', 'white', vertical=True)

    # Crop the temporary image to the actual height of the text
    y_offset = 0
    for char in padded_japanese_text:
        char_font = rotated_font if char in rotated_chars else font_large
        char = rotated_chars.get(char, char)
        char = rotated_letters.get(char, char)
        text_bbox = get_text_bbox(temp_draw3, char, char_font)
        char_height = (text_bbox[3] + text_bbox[1])
        y_offset += char_height

    # Crop the temporary image to the actual height of the text
    temp_img3 = temp_img3.crop((0, 0, 96, y_offset))

    # Resize the image if it exceeds the specified height
    if y_offset > img3_height:
        img3_1 = temp_img3.resize((96, img3_height), Image.Resampling.LANCZOS)
    else:
        img3_1 = temp_img3.crop((0, 0, 96, img3_height))

    generate_image(temp_sub_draw3, japanese_sub_text, font_medium, rotated_font, (96, 3000), (32, 156), 'center', 4, 'black', 'white', vertical_small=True)

    # Crop the temporary image to the actual height of the text
    y_offset = 0
    for char in japanese_sub_text:
        char_font = rotated_font if char in rotated_chars else font_medium
        char = rotated_chars.get(char, char)
        char = rotated_letters.get(char, char)
        text_bbox = get_text_bbox(temp_sub_draw3, char, char_font)
        char_height = round((text_bbox[3] + text_bbox[1]) * 1.1)
        y_offset += char_height

    # Crop the temporary image to the actual height of the text
    temp_sub_img3 = temp_sub_img3.crop((0, 0, 96, y_offset))

    # Resize the image if it exceeds the specified height
    if y_offset > img3_height:
        img3_2 = temp_sub_img3.resize((96, img3_height), Image.Resampling.LANCZOS)
    else:
        img3_2 = temp_sub_img3.crop((0, 0, 96, img3_height))

    img3.paste(img3_1, (0, 0))
    img3.paste(img3_2, (0, 0), img3_2) 
    img3.save(os.path.join(folder_name, '3.png'))

    # Image 4.png
    img4_height = 400

    img4 = Image.new('RGBA', (56, 400), color=(0, 0, 0, 0))
    draw4 = ImageDraw.Draw(img4)

    temp_img4 = Image.new('RGBA', (56, 3000), (0, 0, 0, 0))  # Temporary image with 3000px height
    temp_draw4 = ImageDraw.Draw(temp_img4)

    generate_image(temp_draw4, padded_japanese_text, font_large, rotated_font, (56, 400), (48, 0), 'center', 5, genre_color, 'white', vertical=True)

    # Crop the temporary image to the actual height of the text
    y_offset = 0
    for char in padded_japanese_text:
        char_font = rotated_font if char in rotated_chars else font_large
        char = rotated_chars.get(char, char)
        char = rotated_letters.get(char, char)
        text_bbox = get_text_bbox(temp_draw4, char, char_font)
        char_height = (text_bbox[3] + text_bbox[1])
        y_offset += char_height

    # Crop the temporary image to the actual height of the text
    temp_img4 = temp_img4.crop((0, 0, 56, y_offset))

    # Resize the image if it exceeds the specified height
    if y_offset > img4_height:
        img4 = temp_img4.resize((56, img4_height), Image.Resampling.LANCZOS)
    else:
        img4 = temp_img4.crop((0, 0, 56, img4_height))

    img4.save(os.path.join(folder_name, '4.png'))

    # Image 5.png
    img5_height = 400

    img5 = Image.new('RGBA', (56, 400), color=(0, 0, 0, 0))
    draw5 = ImageDraw.Draw(img5)

    temp_img5 = Image.new('RGBA', (56, 3000), (0, 0, 0, 0))  # Temporary image with 1000px height
    temp_draw5 = ImageDraw.Draw(temp_img5)

    generate_image(temp_draw5, padded_japanese_text, font_large, rotated_font, (56, 400), (48, 0), 'center', 5, 'black', 'white', vertical=True)

    # Crop the temporary image to the actual height of the text
    y_offset = 0
    for char in padded_japanese_text:
        char_font = rotated_font if char in rotated_chars else font_large
        char = rotated_chars.get(char, char)
        char = rotated_letters.get(char, char)
        text_bbox = get_text_bbox(temp_draw5, char, char_font)
        char_height = (text_bbox[3] + text_bbox[1])
        y_offset += char_height

    # Crop the temporary image to the actual height of the text
    temp_img5 = temp_img5.crop((0, 0, 56, y_offset))

    # Resize the image if it exceeds the specified height
    if y_offset > img5_height:
        img5 = temp_img5.resize((56, img5_height), Image.Resampling.LANCZOS)
    else:
        img5 = temp_img5.crop((0, 0, 56, img5_height))

    img5.save(os.path.join(folder_name, '5.png'))

def generate_wiiu3_texture(id, genreNo, current_unique_id, append_ura, custom_songs):
    # Load your JSON data from a file
    if custom_songs == True:
        with open(rf'{custom_wordlist_path}', encoding='utf-8') as f:
            data = json.load(f)
    else:
        with open(rf'{wordlist_path}', encoding='utf-8') as f:
            data = json.load(f)

    font_path = 'data/_resource/font/DFPKanTeiRyu-XB.ttf'
    rotated_font_path = 'data/_resource/font/KozGoPr6NRegular.otf'
    create_images(data, id, genreNo, font_path, rotated_font_path, current_unique_id, append_ura)

class TextureSurface:
    def __init__(self):
        self.mipmaps = []

class NutTexture:
    def __init__(self, width, height, pixel_format, pixel_type):
        self.surfaces = [TextureSurface()]
        self.Width = width
        self.Height = height
        self.pixelInternalFormat = pixel_format
        self.pixelFormat = pixel_type
        self.HashId = 0

    def add_mipmap(self, mipmap_data):
        self.surfaces[0].mipmaps.append(mipmap_data)

    @property
    def MipMapsPerSurface(self):
        return len(self.surfaces[0].mipmaps)

    def getNutFormat(self):
        if self.pixelInternalFormat == 'CompressedRgbaS3tcDxt1Ext':
            return 0
        elif self.pixelInternalFormat == 'CompressedRgbaS3tcDxt3Ext':
            return 1
        elif self.pixelInternalFormat == 'CompressedRgbaS3tcDxt5Ext':
            return 2
        elif self.pixelInternalFormat == 'RGBA':
            if self.pixelFormat == 'RGBA':
                return 14
            elif self.pixelFormat == 'ABGR':
                return 16
            else:
                return 17
        else:
            raise NotImplementedError(f"Unknown pixel format {self.pixelInternalFormat}")

class NUT:
    def __init__(self):
        self.textures = []
        self.endian = 'big'
        self.version = 0x0200

    def add_texture(self, texture):
        self.textures.append(texture)

    def save(self, filename):
        with open(filename, 'wb') as f:
            f.write(self.build())

    def build(self):
        o = bytearray()
        data = bytearray()

        if self.endian == 'big':
            o.extend(struct.pack('>I', 0x4E545033))  # NTP3
        else:
            o.extend(struct.pack('>I', 0x4E545744))  # NTWD

        if self.version > 0x0200:
            self.version = 0x0200

        o.extend(struct.pack('>H', self.version))
        num_textures = len(self.textures)
        if num_textures != 1 and num_textures != 6:
            raise ValueError("The number of images must be either 1 or 6.")
        o.extend(struct.pack('>H', num_textures))
        o.extend(b'\x00' * 8)  # Reserved space

        header_length = 0
        for texture in self.textures:
            surface_count = len(texture.surfaces)
            is_cubemap = surface_count == 6
            if surface_count < 1 or surface_count > 6:
                raise NotImplementedError(f"Unsupported surface amount {surface_count} for texture. 1 to 6 faces are required.")
            if surface_count > 1 and surface_count < 6:
                raise NotImplementedError(f"Unsupported cubemap face amount for texture. Six faces are required.")
            mipmap_count = len(texture.surfaces[0].mipmaps)
            header_size = 0x50 + (0x10 if is_cubemap else 0) + (mipmap_count * 4 if mipmap_count > 1 else 0)
            header_size = (header_size + 0xF) & ~0xF  # Align to 16 bytes
            header_length += header_size

        for texture in self.textures:
            surface_count = len(texture.surfaces)
            is_cubemap = surface_count == 6
            mipmap_count = len(texture.surfaces[0].mipmaps)

            data_size = sum((len(mipmap) + 0xF) & ~0xF for mipmap in texture.surfaces[0].mipmaps)
            header_size = 0x50 + (0x10 if is_cubemap else 0) + (mipmap_count * 4 if mipmap_count > 1 else 0)
            header_size = (header_size + 0xF) & ~0xF

            o.extend(struct.pack('>I', data_size + header_size))
            o.extend(b'\x00' * 4)  # Padding
            o.extend(struct.pack('>I', data_size))
            o.extend(struct.pack('>H', header_size))
            o.extend(b'\x00' * 2)  # Padding

            o.extend(b'\x00')
            o.extend(struct.pack('B', mipmap_count))
            o.extend(b'\x00')
            o.extend(struct.pack('B', texture.getNutFormat()))
            o.extend(struct.pack('>HH', texture.Width, texture.Height))
            o.extend(b'\x00' * 4)  # Padding
            o.extend(struct.pack('>I', 0))  # DDS Caps2 placeholder

            if self.version >= 0x0200:
                o.extend(struct.pack('>I', header_length + len(data)))
            else:
                o.extend(b'\x00' * 4)  # Padding

            header_length -= header_size
            o.extend(b'\x00' * 12)  # Reserved space

            if is_cubemap:
                o.extend(struct.pack('>II', len(texture.surfaces[0].mipmaps[0]), len(texture.surfaces[0].mipmaps[0])))
                o.extend(b'\x00' * 8)  # Padding

            if texture.getNutFormat() == 14 or texture.getNutFormat() == 17:
                self.swap_channel_order_down(texture)

            for surface in texture.surfaces:
                for mipmap in surface.mipmaps:
                    mip_start = len(data)
                    data.extend(mipmap)
                    while len(data) % 0x10 != 0:
                        data.extend(b'\x00')
                    if mipmap_count > 1:
                        mip_end = len(data)
                        o.extend(struct.pack('>I', mip_end - mip_start))

            while len(o) % 0x10 != 0:
                o.extend(b'\x00')

            if texture.getNutFormat() == 14 or texture.getNutFormat() == 17:
                self.swap_channel_order_up(texture)

            o.extend(b'\x65\x58\x74\x00')  # "eXt\0"
            o.extend(struct.pack('>II', 0x20, 0x10))
            o.extend(b'\x00' * 4)

            o.extend(b'\x47\x49\x44\x58')  # "GIDX"
            o.extend(struct.pack('>I', 0x10))
            o.extend(struct.pack('>I', texture.HashId))  # Texture ID
            o.extend(b'\x00' * 4)

        o.extend(data)

        return o

    def swap_channel_order_down(self, texture):
        for surface in texture.surfaces:
            for i, mipmap in enumerate(surface.mipmaps):
                mipmap = bytearray(mipmap)
                for j in range(0, len(mipmap), 4):
                    mipmap[j], mipmap[j + 2] = mipmap[j + 2], mipmap[j]
                surface.mipmaps[i] = bytes(mipmap)

    def swap_channel_order_up(self, texture):
        for surface in texture.surfaces:
            for i, mipmap in enumerate(surface.mipmaps):
                mipmap = bytearray(mipmap)
                for j in range(0, len(mipmap), 4):
                    mipmap[j], mipmap[j + 2] = mipmap[j + 2], mipmap[j]
                surface.mipmaps[i] = bytes(mipmap)

def nvcompress_png_to_dds(png_filepath, dds_filepath, format_option):
    format_map = {
        'dxt1': '-bc1a',
        'dxt3': '-bc2',
        'dxt5': '-bc3',
    }
    format_arg = format_map.get(format_option.lower(), '-bc1')
    command = f"nvcompress {format_arg} {png_filepath} {dds_filepath}"
    subprocess.run(command, shell=True, check=True)

def load_dds_to_texture(dds_filepath, index, pixel_format):
    DDS_HEADER_SIZE = 128  # DDS header size in bytes
    with open(dds_filepath, 'rb') as dds_file:
        dds_data = dds_file.read()
        print(f"Length of dds_data: {len(dds_data)}")
        print(f"Bytes from 12 to 20: {dds_data[12:20]}")
        width, height = struct.unpack_from('<II', dds_data, 12)[:2]
        texture = NutTexture(height, width, pixel_format, pixel_format)
        texture.add_mipmap(dds_data[DDS_HEADER_SIZE:])  # Skip the DDS header
        texture.HashId = index  # Set HashId based on the index
        return texture

def generate_nut_from_pngs(png_folder, output_nut_path, format_option):
    nut = NUT()
    png_files = [f for f in os.listdir(png_folder) if f.lower().endswith('.png')]
    for index, png_file in enumerate(png_files):
        png_path = os.path.join(png_folder, png_file)
        dds_path = os.path.splitext(png_path)[0] + '.dds'
        nvcompress_png_to_dds(png_path, dds_path, format_option)
        texture = load_dds_to_texture(dds_path, index, f'CompressedRgbaS3tc{format_option.capitalize()}Ext')
        nut.add_texture(texture)
    nut.save(output_nut_path)

def generate_nut_texture(input_folder, output_file):
    if texture_quality == "low":
        generate_nut_from_pngs(input_folder, output_file, 'dxt1')
    else:
        generate_nut_from_pngs(input_folder, output_file, 'dxt5')

# file encryption
    
def encrypt_file_ptb(input_file, output_file):
    # Generate a random initialization vector (IV)
    iv = os.urandom(16)  # AES block size is 16 bytes

    # Pad the key if necessary (AES-128 requires a 16-byte key)
    key = bytes.fromhex("54704643596B474170554B6D487A597A")

    # Create an AES CBC cipher with the given key and IV
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()

    with open(input_file, 'rb') as f_in:
        with open(output_file, 'wb') as f_out:
            # Write the IV to the output file (needed for decryption)
            f_out.write(iv)

            # Encrypt the file chunk by chunk
            while True:
                chunk = f_in.read(16)  # Read 16 bytes at a time
                if len(chunk) == 0:
                    break
                elif len(chunk) % 16 != 0:
                    # Add padding to the last block if needed
                    padder = padding.PKCS7(128).padder()
                    padded_data = padder.update(chunk) + padder.finalize()
                    chunk = padded_data
                encrypted_chunk = encryptor.update(chunk)
                f_out.write(encrypted_chunk)

            # Finalize the encryption (encryptor might have remaining data)
            final_chunk = encryptor.finalize()
            f_out.write(final_chunk)

def encrypt_file_ns1(input_file, output_file):
    # Generate a random initialization vector (IV)
    iv = os.urandom(16)  # AES block size is 16 bytes

    # Pad the key if necessary (AES-128 requires a 16-byte key)
    key = bytes.fromhex("566342346438526962324A366334394B")

    # Create an AES CBC cipher with the given key and IV
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()

    with open(input_file, 'rb') as f_in:
        with open(output_file, 'wb') as f_out:
            # Write the IV to the output file (needed for decryption)
            f_out.write(iv)

            # Encrypt the file chunk by chunk
            while True:
                chunk = f_in.read(16)  # Read 16 bytes at a time
                if len(chunk) == 0:
                    break
                elif len(chunk) % 16 != 0:
                    # Add padding to the last block if needed
                    padder = padding.PKCS7(128).padder()
                    padded_data = padder.update(chunk) + padder.finalize()
                    chunk = padded_data
                encrypted_chunk = encryptor.update(chunk)
                f_out.write(encrypted_chunk)

            # Finalize the encryption (encryptor might have remaining data)
            final_chunk = encryptor.finalize()
            f_out.write(final_chunk)


def gzip_compress_file(input_file_path):
    # Extract the base filename without extension
    file_name, file_ext = os.path.splitext(input_file_path)
    
    # Output file path with .gz extension appended
    output_file_path = f'{file_name}.gz'
    
    with open(input_file_path, 'rb') as f_in:
        with gzip.open(output_file_path, 'wb') as f_out:
            f_out.writelines(f_in)
    
    return output_file_path

def gzip_compress_file_ps4(input_file_path):
    # Extract the base filename without extension
    file_name, file_ext = os.path.splitext(input_file_path)
    
    # Output file path with .gz extension appended
    output_file_path = f'{file_name}.bin'
    
    with open(input_file_path, 'rb') as f_in:
        with gzip.open(output_file_path, 'wb') as f_out:
            f_out.writelines(f_in)
    
    return output_file_path

def copy_folder(source_folder, destination_folder):
    """
    Copy the entire contents of source_folder to destination_folder.
    
    Args:
        source_folder (str): Path to the source folder to copy.
        destination_folder (str): Path to the destination folder.
    
    Returns:
        bool: True if copy operation is successful, False otherwise.
    """
    try:
        # Check if destination folder already exists
        if os.path.exists(destination_folder):
            print(f"Destination folder '{destination_folder}' already exists. Skipping copy.")
            return False
        
        # Copy the entire folder from source to destination
        shutil.copytree(source_folder, destination_folder)
        print(f"Folder '{source_folder}' successfully copied to '{destination_folder}'.")
        return True
    
    except shutil.Error as e:
        print(f"Error: {e}")
        return False
    
    except OSError as e:
        print(f"Error: {e}")
        return False

def create_wiiu3_song_info_xml(song_info, current_unique_id, song_order, word_list):
    # Create the root element DB_DATA

    #db_data = ET.Element('DB_DATA', num=str(db_data_count))

    data_set = ET.Element('DATA_SET')
    
    def add_element(parent, tag, text):
        element = ET.SubElement(parent, tag)
        element.text = text
    
    song_id = song_info["id"]
    word_keys = [f"song_{song_id}", f"song_sub_{song_id}", f"song_detail_{song_id}"]
    
    word_info = None
    for key in word_keys:
        word_info = next((item for item in word_list["items"] if item["key"] == key), None)
        if word_info:
            break

    title = word_info.get("japaneseText", "") if word_info else ""

    # Combine "song_" with song_info["id"] to form the attribute value
    attribute_value = "song_" + str(song_info["id"])

    add_element(data_set, 'uniqueId', str(current_unique_id))
    add_element(data_set, 'id', song_info["id"])
    add_element(data_set, 'fumenFilePath', "/%AOC%/")
    add_element(data_set, 'songFilePath', "/%AOC%/sound/")
    add_element(data_set, 'songFileName', attribute_value)
    add_element(data_set, 'title', title)
    add_element(data_set, 'order', str(song_order))
        #Stupid fucking Genre fix for Vocaloid and Variety
    if str(song_info["genreNo"]) == "2":
        add_element(data_set, 'genreNo', "3")
    elif str(song_info["genreNo"]) == "3":
        add_element(data_set, 'genreNo', "2")
    else:
        add_element(data_set, 'genreNo', str(song_info["genreNo"]))
    add_element(data_set, 'songTitlePath', "/%AOC%/texture/")
    add_element(data_set, 'songWordsPath', " ")
    add_element(data_set, 'songWordsFileName', " ")
    add_element(data_set, 'secret', " ")
    add_element(data_set, 'releaseType', "0")
    add_element(data_set, 'ura', " ")
    add_element(data_set, 'dlc', "○")
    add_element(data_set, 'debug', " ")
    add_element(data_set, 'batonInterval', "2")
    add_element(data_set, 'isNotVsDuet', " ")
    if song_info["branchEasy"] == True:
        add_element(data_set, 'branchEasy', "○")
    else:
        add_element(data_set, 'branchEasy', "")
    if song_info["branchNormal"] == True:
        add_element(data_set, 'branchNormal', "○")
    else:
        add_element(data_set, 'branchNormal', "")
    if song_info["branchHard"] == True:
        add_element(data_set, 'branchHard', "○")
    else:
        add_element(data_set, 'branchHard', "")
    if song_info["branchMania"] == True:
        add_element(data_set, 'branchMania', "○")
    else:
        add_element(data_set, 'branchMania', "")
    add_element(data_set, 'starEasy', str(song_info["starEasy"]))
    add_element(data_set, 'starNormal', str(song_info["starNormal"]))
    add_element(data_set, 'starHard', str(song_info["starHard"]))
    add_element(data_set, 'starMania', str(song_info["starMania"]))
    add_element(data_set, 'donBg1pLumen', " ")
    add_element(data_set, 'donBg1pPath', " ")
    add_element(data_set, 'donBg2pLumen', " ")
    add_element(data_set, 'donBg2pPath', " ")
    add_element(data_set, 'chibiLumen', " ")
    add_element(data_set, 'chibiPath', " ")
    add_element(data_set, 'danceLumen', " ")
    add_element(data_set, 'dancePath', " ")
    add_element(data_set, 'danceNormalBgLumen', " ")
    add_element(data_set, 'danceNormalBgPath', " ")
    add_element(data_set, 'danceFeverBgLumen', " ")
    add_element(data_set, 'danceFeverBgPath', " ")
    add_element(data_set, 'danceDodaiLumen', " ")
    add_element(data_set, 'danceDodaiPath', " ")
    add_element(data_set, 'feverLumen', " ")
    add_element(data_set, 'feverPath', " ")
    add_element(data_set, 'rendaEffectLumen', " ")
    add_element(data_set, 'rendaEffectPath', " ")
    add_element(data_set, 'donBg1pLumen2', " ")
    add_element(data_set, 'donBg1pPath2', " ")
    add_element(data_set, 'donBg2pLumen2', " ")
    add_element(data_set, 'donBg2pPath2', " ")
    add_element(data_set, 'chibiLumen2', " ")
    add_element(data_set, 'chibiPath2', " ")
    add_element(data_set, 'danceLumen2', " ")
    add_element(data_set, 'dancePath2', " ")
    add_element(data_set, 'danceNormalBgLumen2', " ")
    add_element(data_set, 'danceNormalBgPath2', " ")
    add_element(data_set, 'danceFeverBgLumen2', " ")
    add_element(data_set, 'danceFeverBgPath2', " ")
    add_element(data_set, 'danceDodaiLumen2', " ")
    add_element(data_set, 'danceDodaiPath2', " ")
    add_element(data_set, 'feverLumen2', " ")
    add_element(data_set, 'feverPath2', " ")
    add_element(data_set, 'rendaEffectLumen2', " ")
    add_element(data_set, 'rendaEffectPath2', " ")
    
    return data_set

def create_wiiu3_song_info_extreme_xml(song_info, current_unique_id, song_order, word_list):
    # Create the root element DB_DATA

    #db_data = ET.Element('DB_DATA', num=str(db_data_count))

    data_set = ET.Element('DATA_SET')
    
    def add_element(parent, tag, text):
        element = ET.SubElement(parent, tag)
        element.text = text
    
    song_id = song_info["id"]
    word_keys = [f"song_{song_id}", f"song_sub_{song_id}", f"song_detail_{song_id}"]
    
    word_info = None
    for key in word_keys:
        word_info = next((item for item in word_list["items"] if item["key"] == key), None)
        if word_info:
            break

    title = word_info.get("japaneseText", "") if word_info else ""

    # Combine "song_" with song_info["id"] to form the attribute value
    attribute_value = "song_" + str(song_info["id"])

    add_element(data_set, 'uniqueId', str(current_unique_id))
    add_element(data_set, 'id', song_info["id"])
    add_element(data_set, 'fumenFilePath', "/%AOC%/")
    add_element(data_set, 'songFilePath', "/%AOC%/sound/")
    add_element(data_set, 'songFileName', attribute_value)
    add_element(data_set, 'title', title)
    add_element(data_set, 'order', str(song_order))
    #Stupid fucking Genre fix for Vocaloid and Variety
    if str(song_info["genreNo"]) == "2":
        add_element(data_set, 'genreNo', "3")
    elif str(song_info["genreNo"]) == "3":
        add_element(data_set, 'genreNo', "2")
    else:
        add_element(data_set, 'genreNo', str(song_info["genreNo"]))
    add_element(data_set, 'songTitlePath', "/%AOC%/texture/")
    add_element(data_set, 'songWordsPath', " ")
    add_element(data_set, 'songWordsFileName', " ")
    add_element(data_set, 'secret', " ")
    add_element(data_set, 'releaseType', "0")
    add_element(data_set, 'ura', "○")
    add_element(data_set, 'dlc', "○")
    add_element(data_set, 'debug', " ")
    add_element(data_set, 'batonInterval', "2")
    add_element(data_set, 'isNotVsDuet', " ")
    add_element(data_set, 'branchEasy', " ")
    add_element(data_set, 'branchNormal', " ")
    add_element(data_set, 'branchHard', " ")
    if song_info["branchMania"] == True:
        add_element(data_set, 'branchMania', "○")
    else:
        add_element(data_set, 'branchMania', "")
    add_element(data_set, 'starEasy', " ")
    add_element(data_set, 'starNormal', " ")
    add_element(data_set, 'starHard', " ")
    add_element(data_set, 'starMania', str(song_info["starMania"]))
    add_element(data_set, 'donBg1pLumen', " ")
    add_element(data_set, 'donBg1pPath', " ")
    add_element(data_set, 'donBg2pLumen', " ")
    add_element(data_set, 'donBg2pPath', " ")
    add_element(data_set, 'chibiLumen', " ")
    add_element(data_set, 'chibiPath', " ")
    add_element(data_set, 'danceLumen', " ")
    add_element(data_set, 'dancePath', " ")
    add_element(data_set, 'danceNormalBgLumen', " ")
    add_element(data_set, 'danceNormalBgPath', " ")
    add_element(data_set, 'danceFeverBgLumen', " ")
    add_element(data_set, 'danceFeverBgPath', " ")
    add_element(data_set, 'danceDodaiLumen', " ")
    add_element(data_set, 'danceDodaiPath', " ")
    add_element(data_set, 'feverLumen', " ")
    add_element(data_set, 'feverPath', " ")
    add_element(data_set, 'rendaEffectLumen', " ")
    add_element(data_set, 'rendaEffectPath', " ")
    add_element(data_set, 'donBg1pLumen2', " ")
    add_element(data_set, 'donBg1pPath2', " ")
    add_element(data_set, 'donBg2pLumen2', " ")
    add_element(data_set, 'donBg2pPath2', " ")
    add_element(data_set, 'chibiLumen2', " ")
    add_element(data_set, 'chibiPath2', " ")
    add_element(data_set, 'danceLumen2', " ")
    add_element(data_set, 'dancePath2', " ")
    add_element(data_set, 'danceNormalBgLumen2', " ")
    add_element(data_set, 'danceNormalBgPath2', " ")
    add_element(data_set, 'danceFeverBgLumen2', " ")
    add_element(data_set, 'danceFeverBgPath2', " ")
    add_element(data_set, 'danceDodaiLumen2', " ")
    add_element(data_set, 'danceDodaiPath2', " ")
    add_element(data_set, 'feverLumen2', " ")
    add_element(data_set, 'feverPath2', " ")
    add_element(data_set, 'rendaEffectLumen2', " ")
    add_element(data_set, 'rendaEffectPath2', " ")
    
    return data_set

def create_wiiu3_song_info_hard_xml(song_info, current_unique_id, song_order, word_list):
    # Create the root element DB_DATA

    #db_data = ET.Element('DB_DATA', num=str(db_data_count))

    data_set = ET.Element('DATA_SET')
    
    def add_element(parent, tag, text):
        element = ET.SubElement(parent, tag)
        element.text = text
    
    song_id = song_info["id"]
    word_keys = [f"song_{song_id}", f"song_sub_{song_id}", f"song_detail_{song_id}"]
    
    word_info = None
    for key in word_keys:
        word_info = next((item for item in word_list["items"] if item["key"] == key), None)
        if word_info:
            break

    title = word_info.get("japaneseText", "") if word_info else ""

    # Combine "song_" with song_info["id"] to form the attribute value
    attribute_value = "song_" + str(song_info["id"])

    add_element(data_set, 'uniqueId', str(current_unique_id))
    add_element(data_set, 'id', song_info["id"])
    add_element(data_set, 'fumenFilePath', "/%AOC%/")
    add_element(data_set, 'songFilePath', "/%AOC%/sound/")
    add_element(data_set, 'songFileName', attribute_value)
    add_element(data_set, 'title', title)
    add_element(data_set, 'order', str(song_order))
    #Stupid fucking Genre fix for Vocaloid and Variety
    if str(song_info["genreNo"]) == "2":
        add_element(data_set, 'genreNo', "3")
    elif str(song_info["genreNo"]) == "3":
        add_element(data_set, 'genreNo', "2")
    else:
        add_element(data_set, 'genreNo', str(song_info["genreNo"]))
    add_element(data_set, 'songTitlePath', "/%AOC%/texture/")
    add_element(data_set, 'songWordsPath', " ")
    add_element(data_set, 'songWordsFileName', " ")
    add_element(data_set, 'secret', " ")
    add_element(data_set, 'releaseType', "0")
    add_element(data_set, 'ura', "○")
    add_element(data_set, 'dlc', "○")
    add_element(data_set, 'debug', " ")
    add_element(data_set, 'batonInterval', "2")
    add_element(data_set, 'isNotVsDuet', " ")
    add_element(data_set, 'branchEasy', " ")
    add_element(data_set, 'branchNormal', " ")
    add_element(data_set, 'branchHard', " ")
    if song_info["branchHard"] == True:
        add_element(data_set, 'branchHard', "○")
    else:
        add_element(data_set, 'branchHard', "")
    add_element(data_set, 'starEasy', " ")
    add_element(data_set, 'starNormal', " ")
    add_element(data_set, 'starHard', " ")
    add_element(data_set, 'starMania', str(song_info["starHard"]))
    add_element(data_set, 'donBg1pLumen', " ")
    add_element(data_set, 'donBg1pPath', " ")
    add_element(data_set, 'donBg2pLumen', " ")
    add_element(data_set, 'donBg2pPath', " ")
    add_element(data_set, 'chibiLumen', " ")
    add_element(data_set, 'chibiPath', " ")
    add_element(data_set, 'danceLumen', " ")
    add_element(data_set, 'dancePath', " ")
    add_element(data_set, 'danceNormalBgLumen', " ")
    add_element(data_set, 'danceNormalBgPath', " ")
    add_element(data_set, 'danceFeverBgLumen', " ")
    add_element(data_set, 'danceFeverBgPath', " ")
    add_element(data_set, 'danceDodaiLumen', " ")
    add_element(data_set, 'danceDodaiPath', " ")
    add_element(data_set, 'feverLumen', " ")
    add_element(data_set, 'feverPath', " ")
    add_element(data_set, 'rendaEffectLumen', " ")
    add_element(data_set, 'rendaEffectPath', " ")
    add_element(data_set, 'donBg1pLumen2', " ")
    add_element(data_set, 'donBg1pPath2', " ")
    add_element(data_set, 'donBg2pLumen2', " ")
    add_element(data_set, 'donBg2pPath2', " ")
    add_element(data_set, 'chibiLumen2', " ")
    add_element(data_set, 'chibiPath2', " ")
    add_element(data_set, 'danceLumen2', " ")
    add_element(data_set, 'dancePath2', " ")
    add_element(data_set, 'danceNormalBgLumen2', " ")
    add_element(data_set, 'danceNormalBgPath2', " ")
    add_element(data_set, 'danceFeverBgLumen2', " ")
    add_element(data_set, 'danceFeverBgPath2', " ")
    add_element(data_set, 'danceDodaiLumen2', " ")
    add_element(data_set, 'danceDodaiPath2', " ")
    add_element(data_set, 'feverLumen2', " ")
    add_element(data_set, 'feverPath2', " ")
    add_element(data_set, 'rendaEffectLumen2', " ")
    add_element(data_set, 'rendaEffectPath2', " ")
    
    return data_set

def create_wiiu3_song_info_ura_xml(song_info, current_unique_id, song_order, word_list):
    # Create the root element DB_DATA

    #db_data = ET.Element('DB_DATA', num=str(db_data_count))

    data_set = ET.Element('DATA_SET')
    
    def add_element(parent, tag, text):
        element = ET.SubElement(parent, tag)
        element.text = text
    
    song_id = song_info["id"]
    word_keys = [f"song_{song_id}", f"song_sub_{song_id}", f"song_detail_{song_id}"]
    
    word_info = None
    for key in word_keys:
        word_info = next((item for item in word_list["items"] if item["key"] == key), None)
        if word_info:
            break

    title = word_info.get("japaneseText", "") if word_info else ""

    # Combine "song_" with song_info["id"] to form the attribute value
    attribute_value = "song_" + str(song_info["id"])

    add_element(data_set, 'uniqueId', str(current_unique_id))
    add_element(data_set, 'id', 'ex_' + song_info["id"])
    add_element(data_set, 'fumenFilePath', "/%AOC%/")
    add_element(data_set, 'songFilePath', "/%AOC%/sound/")
    add_element(data_set, 'songFileName', attribute_value)
    add_element(data_set, 'title', title)
    add_element(data_set, 'order', str(song_order))
    #Stupid fucking Genre fix for Vocaloid and Variety
    if str(song_info["genreNo"]) == "2":
        add_element(data_set, 'genreNo', "3")
    elif str(song_info["genreNo"]) == "3":
        add_element(data_set, 'genreNo', "2")
    else:
        add_element(data_set, 'genreNo', str(song_info["genreNo"]))
    add_element(data_set, 'songTitlePath', "/%AOC%/texture/")
    add_element(data_set, 'songWordsPath', " ")
    add_element(data_set, 'songWordsFileName', " ")
    add_element(data_set, 'secret', " ")
    add_element(data_set, 'releaseType', "0")
    add_element(data_set, 'ura', "○")
    add_element(data_set, 'dlc', "○")
    add_element(data_set, 'debug', " ")
    add_element(data_set, 'batonInterval', "2")
    add_element(data_set, 'isNotVsDuet', " ")
    add_element(data_set, 'branchEasy', " ")
    add_element(data_set, 'branchNormal', " ")
    add_element(data_set, 'branchHard', " ")
    if song_info["branchUra"] == True:
        add_element(data_set, 'branchMania', "○")
    else:
        add_element(data_set, 'branchMania', "")
    add_element(data_set, 'starEasy', " ")
    add_element(data_set, 'starNormal', " ")
    add_element(data_set, 'starHard', " ")
    add_element(data_set, 'starMania', str(song_info["starUra"]))
    add_element(data_set, 'donBg1pLumen', " ")
    add_element(data_set, 'donBg1pPath', " ")
    add_element(data_set, 'donBg2pLumen', " ")
    add_element(data_set, 'donBg2pPath', " ")
    add_element(data_set, 'chibiLumen', " ")
    add_element(data_set, 'chibiPath', " ")
    add_element(data_set, 'danceLumen', " ")
    add_element(data_set, 'dancePath', " ")
    add_element(data_set, 'danceNormalBgLumen', " ")
    add_element(data_set, 'danceNormalBgPath', " ")
    add_element(data_set, 'danceFeverBgLumen', " ")
    add_element(data_set, 'danceFeverBgPath', " ")
    add_element(data_set, 'danceDodaiLumen', " ")
    add_element(data_set, 'danceDodaiPath', " ")
    add_element(data_set, 'feverLumen', " ")
    add_element(data_set, 'feverPath', " ")
    add_element(data_set, 'rendaEffectLumen', " ")
    add_element(data_set, 'rendaEffectPath', " ")
    add_element(data_set, 'donBg1pLumen2', " ")
    add_element(data_set, 'donBg1pPath2', " ")
    add_element(data_set, 'donBg2pLumen2', " ")
    add_element(data_set, 'donBg2pPath2', " ")
    add_element(data_set, 'chibiLumen2', " ")
    add_element(data_set, 'chibiPath2', " ")
    add_element(data_set, 'danceLumen2', " ")
    add_element(data_set, 'dancePath2', " ")
    add_element(data_set, 'danceNormalBgLumen2', " ")
    add_element(data_set, 'danceNormalBgPath2', " ")
    add_element(data_set, 'danceFeverBgLumen2', " ")
    add_element(data_set, 'danceFeverBgPath2', " ")
    add_element(data_set, 'danceDodaiLumen2', " ")
    add_element(data_set, 'danceDodaiPath2', " ")
    add_element(data_set, 'feverLumen2', " ")
    add_element(data_set, 'feverPath2', " ")
    add_element(data_set, 'rendaEffectLumen2', " ")
    add_element(data_set, 'rendaEffectPath2', " ")
    
    return data_set

def indent(elem, level=0):
    i = "\n" + level * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for subelem in elem:
            indent(subelem, level + 1)
        if not subelem.tail or not subelem.tail.strip():
            subelem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i

def save_xml_to_file(xml_element, file_path):
    indent(xml_element)
    tree = ET.ElementTree(xml_element)
    tree.write(file_path, encoding='utf-8', xml_declaration=True)

# Initialize root element
root = ET.Element('DB_DATA')

# wii u file fuckery
def process_music_info(current_unique_id):
    # Define paths

    formatted_id = f"{current_unique_id:04d}"
    source_file = r'data\_resource\templates\musicInfo.drp'
    target_folder = rf'\out\content\{formatted_id}'
    executable_path = r'data\_resource\executable\DRPRepacker.exe'
    
    # Step 1: Copy file to target folder
    shutil.copy(source_file, os.getcwd() + target_folder)
    
    # Step 2: Run executable
    subprocess.run([executable_path, 'musicInfo.drp', 'musicInfo'], cwd=os.getcwd() + target_folder)
    
    # Step 3: Delete original file
    os.remove(os.getcwd() + target_folder + r'\musicInfo.drp')
    
    # Step 4: Rename repacked file
    os.rename(os.getcwd() + target_folder + r'\repacked.drp', os.getcwd() + target_folder + r'\musicInfo.drp')


def convert_endian(input_path, output_path, direction):
    ibo = obo = None  # in byte order, out byte order

    # Determine input and output byte order based on direction
    try:
        if direction.lower() == 'lb':
            ibo = '<'  # Little Endian
            obo = '>'  # Big Endian
        elif direction.lower() == 'bl':
            ibo = '>'  # Big Endian
            obo = '<'  # Little Endian
        else:
            raise ValueError(f'Invalid direction "{direction}"!')
    except ValueError as e:
        print(f'Error: {e}')
        return

    same_file = output_path == input_path

    if same_file:
        output_path += '.r'

    try:
        with open(input_path, 'rb') as fin:
            with open(output_path, 'wb') as fout:
                for hanteiI in range(36 * 3):
                    fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # hantei notes

                while fin.tell() != 0x200:
                    fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # header stuff like tamashii rate

                num_section = struct.unpack(ibo + 'I', fin.read(4))[0]
                fout.write(struct.pack(obo + 'I', num_section))  # num_section
                fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # unknown

                for sectionI in range(num_section):
                    fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # bpm
                    fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # start_time
                    fout.write(struct.pack(obo + 'B', struct.unpack(ibo + 'B', fin.read(1))[0]))  # gogo
                    fout.write(struct.pack(obo + 'B', struct.unpack(ibo + 'B', fin.read(1))[0]))  # section_line
                    fout.write(struct.pack(obo + 'H', struct.unpack(ibo + 'H', fin.read(2))[0]))  # unknown

                    for bunkiI in range(6):
                        fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # bunkis

                    fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # unknown

                    for routeI in range(3):
                        num_notes = struct.unpack(ibo + 'H', fin.read(2))[0]
                        fout.write(struct.pack(obo + 'H', num_notes))  # num_notes
                        fout.write(struct.pack(obo + 'H', struct.unpack(ibo + 'H', fin.read(2))[0]))  # unknown
                        fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # scroll

                        for noteI in range(num_notes):
                            note_type = struct.unpack(ibo + 'I', fin.read(4))[0]
                            fout.write(struct.pack(obo + 'I', note_type))  # note_type
                            fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # headerI1
                            fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # item
                            fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # unknown1
                            fout.write(struct.pack(obo + 'H', struct.unpack(ibo + 'H', fin.read(2))[0]))  # hit
                            fout.write(struct.pack(obo + 'H', struct.unpack(ibo + 'H', fin.read(2))[0]))  # score_inc
                            fout.write(struct.pack(obo + 'f', struct.unpack(ibo + 'f', fin.read(4))[0]))  # length

                            if note_type in [6, 9, 98]:
                                fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # unknown
                                fout.write(struct.pack(obo + 'I', struct.unpack(ibo + 'I', fin.read(4))[0]))  # unknown

        if same_file:
            shutil.move(output_path, input_path)

        print(f'Endian conversion completed: {input_path} -> {output_path}')
        os.remove(input_path)
        print(f'Deleted input file: {input_path}')

    except IOError as e:
        print(f'Error during file operation: {e}')

def process_fumens_files(fumen_output_dir):

    # Ensure fumen_output_dir ends with a slash for proper path joining
    if not fumen_output_dir.endswith('/'):
        fumen_output_dir += '/'

    # Regex pattern to match _1 or _2 in the file name
    duet_pattern = re.compile(r'_[12]\.bin$')

    for root, dirs, files in os.walk(fumen_output_dir):
        for file in files:
            if file.endswith('.bin'):
                input_path = os.path.join(root, file)
                output_dir = ''

                if duet_pattern.search(file):
                    # File contains _1 or _2, save to duet folder
                    output_dir = fumen_output_dir + 'duet/'
                else:
                    # File does not contain _1 or _2, save to solo folder
                    output_dir = fumen_output_dir + 'solo/'

                # Ensure the output directory exists, create if necessary
                os.makedirs(output_dir, exist_ok=True)

                # Construct output path
                output_path = os.path.join(output_dir, file)

                # Perform endian conversion (lb mode)
                convert_endian(input_path, output_path, 'lb')

def cleanup_fumen_output_dir(fumen_output_dir):
    # Ensure fumen_output_dir ends with a slash for proper path joining
    if not fumen_output_dir.endswith('/'):
        fumen_output_dir += '/'

    # List of directories to preserve
    preserve_dirs = ['solo', 'duet']

    # Iterate through all directories in fumen_output_dir
    for dir_name in os.listdir(fumen_output_dir):
        dir_path = os.path.join(fumen_output_dir, dir_name)

        # Check if it's a directory and not in the preserve list
        if os.path.isdir(dir_path) and dir_name not in preserve_dirs:
            try:
                # Clear out *.bin files in the directory
                bin_files = glob.glob(os.path.join(dir_path, '*.bin'))
                for bin_file in bin_files:
                    os.remove(bin_file)
                    print(f"Deleted file: {bin_file}")

                # Delete the directory and all its contents recursively
                shutil.rmtree(dir_path)
                #os.rmdir(dir_path) 
                print(f"Deleted directory: {dir_path}")
            except Exception as e:
                print(f"Error deleting {dir_path}: {e}")

def remove_musicinfo_leftover(directory_path):
    try:
        # Remove all files in the directory
        for file_path in glob.glob(os.path.join(directory_path, '*')):
            if os.path.isfile(file_path):
                os.remove(file_path)
                print(f"Deleted file: {file_path}")

        # Delete the directory itself
        shutil.rmtree(directory_path)
        print(f"Deleted directory: {directory_path}")
    except Exception as e:
        print(f"Error deleting {directory_path}: {e}")


def remove_texture_leftover(texture_output_dir):
    try:
        # Iterate through all files and folders in texture_output_dir
        for path in glob.glob(os.path.join(texture_output_dir, '*')):
            if os.path.isfile(path):
                if path.endswith('.nut'):
                    # Skip *.nut files (preserve them)
                    continue
                else:
                    # Delete all other files
                    os.remove(path)
                    print(f"Deleted file: {path}")
            elif os.path.isdir(path):
                # Delete all directories (folders)
                shutil.rmtree(path)
                print(f"Deleted directory: {path}")

    except Exception as e:
        print(f"Error deleting files and folders in {texture_output_dir}: {e}")


def export_data():
    selected_items = []
    for item_id in tree.get_children():
        if tree.set(item_id, "Select") == "☑":
            selected_items.append(item_id)

    game_platform = game_platform_var.get()

    game_region = game_region_var.get()

    #max_concurrent = config["max_concurrent"]

    if game_platform == "PS4":
        output_dir = "out/Data/ORBIS/datatable"
        fumen_output_dir = "out/Data/ORBIS/fumen"
        fumen_hitwide_output_dir = "out/Data/ORBIS/fumen_hitwide"
        audio_output_dir = "out/Data/ORBIS/sound"
        musicinfo_filename = "musicinfo.json"
        max_entries = 400  # Maximum allowed entries for PS4
        platform_tag = "ps4"
    elif game_platform == "NS1":
        output_dir = "out/Data/NX/datatable"
        fumen_output_dir = "out/Data/NX/fumen/enso"
        fumen_hitwide_output_dir = "out/Data/NX/fumen_hitwide/enso"        
        fumen_hitnarrow_output_dir = "out/Data/NX/fumen_hitnarrow/enso"             
        audio_output_dir = "out/Data/NX/sound"
        musicinfo_filename = "musicinfo.json"
        max_entries = 600  # Maximum allowed entries for NS1
        platform_tag = "ns1"
    elif game_platform == "WIIU3":
        output_dir = "out/content/001A/musicInfo"
        fumen_output_dir = "out/content/001A/fumen"    
        audio_output_dir = "out/content/001A/sound"
        musicinfo_filename = "musicinfo.xml"
        texture_output_dir = "out/content/001A/texture"
        if texture_quality == "low":
            max_entries = 425  # Maximum allowed entries for Wii U 3 with BC1a
        else:
            max_entries = 225  # Maximum allowed entries for Wii U 3 with BC3
        platform_tag = "wiiu3"        
    elif game_platform == "PTB":
        output_dir = "out/Data/Raw/ReadAssets"
        fumen_output_dir = "out/Data/Raw/fumen"
        audio_output_dir = "out/Data/Raw/sound/sound"
        musicinfo_filename = "musicinfo.json"
        songinfo_filename = "songinfo.json"
        max_entries = 200  # Maximum allowed entries for PTB
        platform_tag = "PTB"

    if game_platform == "WIIU3":
        print("")
    else:
        os.makedirs(output_dir, exist_ok=True)
        os.makedirs(fumen_output_dir, exist_ok=True)
        os.makedirs(audio_output_dir, exist_ok=True)

    selected_music_info = []
    selected_song_info = []    
    selected_wordlist = []
    current_unique_id = 0
    if game_platform == "WIIU3":
        current_unique_id = 500
        db_data_count = 0
        formatted_id = f"{current_unique_id:04d}"
        output_dir = f"out/content/{formatted_id}/musicInfo"
        fumen_output_dir = f"out/content/{formatted_id}/fumen"
        audio_output_dir = f"out/content/{formatted_id}/sound"
        texture_output_dir = f"out/content/{formatted_id}/texture"     

        def copy_fumens_ura():
            # Copy fumen folders for selected songs to output directory
            song_id = tree.item(item_id)["values"][1]
    
            # For default fumens
            fumen_folder_path = os.path.join(data_dir, "fumen", str(song_id))
            if os.path.exists(fumen_folder_path):
                for file_name in os.listdir(fumen_folder_path):
                    if file_name.endswith("_x.bin") or file_name.endswith("_x_1.bin") or file_name.endswith("_x_2.bin"):
                            original_path = os.path.join(fumen_folder_path, file_name)
                            new_name = "ex_" + file_name.replace("_x", "_m")
                            destination_path = os.path.join(fumen_output_dir, new_name)
                            shutil.copy2(original_path, destination_path)
                            print(f"Copied and renamed {file_name} to {new_name}")
                    
                # Retrieve song info from music_info
                song_info = next((item for item in music_info["items"] if item["id"] == song_id), None)
    
            # For custom fumens
            if custom_songs:
                custom_fumen_folder_path = os.path.join(custom_data_dir, "fumen", str(song_id))
                if os.path.exists(custom_fumen_folder_path):
                    for file_name in os.listdir(custom_fumen_folder_path):
                        if file_name.endswith("_x.bin") or file_name.endswith("_x_1.bin") or file_name.endswith("_x_2.bin"):
                            original_path = os.path.join(custom_fumen_folder_path, file_name)
                            new_name = "ex_" + file_name.replace("_x", "_m")
                            destination_path = os.path.join(fumen_output_dir, new_name)
                            shutil.copy2(original_path, destination_path)
                            print(f"Copied and renamed {file_name} to {new_name}")
                        
                    # Retrieve song info from custom_music_info
                    song_info = next((item for item in custom_music_info["items"] if item["id"] == song_id), None)

        def copy_fumens():
            # Copy fumen folders for selected songs to output directory
                song_id = tree.item(item_id)["values"][1]
                fumen_folder_path = os.path.join(data_dir, "fumen", str(song_id))
                if os.path.exists(fumen_folder_path):
                    if game_platform == "WIIU3":
                        shutil.copytree(fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))
                        print()
                    else:
                        shutil.copytree(fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))

        def copy_fumens_custom():
            # Copy fumen folders for selected songs to output directory
                song_id = tree.item(item_id)["values"][1]
                fumen_folder_path = os.path.join(custom_data_dir, "fumen", str(song_id))
                if os.path.exists(fumen_folder_path):
                    if game_platform == "WIIU3":
                        shutil.copytree(fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))
                        print()
                    else:
                        shutil.copytree(fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))                                    

    try:
        if len(selected_items) > max_entries:
            messagebox.showerror("Selection Limit Exceeded", f"Maximum {max_entries} entries can be selected for {game_platform}.")
            return

        # Load preview position data
        with open(previewpos_path, "r", encoding="utf-8") as previewpos_file:
            previewpos_data = json.load(previewpos_file)
        
        if custom_songs:
            with open(custom_previewpos_path, "r", encoding="utf-8") as custom_previewpos_file:
                custom_previewpos_data = json.load(custom_previewpos_file)            

    
        # Copy fumen folders for selected songs to output directory
        if game_platform == "WIIU3":
            print()
        else:
            for item_id in selected_items:
                song_id = tree.item(item_id)["values"][1]
                fumen_folder_path = os.path.join(data_dir, "fumen", str(song_id))
                if os.path.exists(fumen_folder_path):
                    shutil.copytree(fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))

                song_info = next((item for item in music_info["items"] if item["id"] == song_id), None)

            if custom_songs:
                for item_id in selected_items:

                    song_id = tree.item(item_id)["values"][1]
                    custom_fumen_folder_path = os.path.join(custom_data_dir, "fumen", str(song_id))
                    if os.path.exists(custom_fumen_folder_path):
                        shutil.copytree(custom_fumen_folder_path, os.path.join(fumen_output_dir, f"{song_id}"))

                    song_info = next((item for item in custom_music_info["items"] if item["id"] == song_id), None)

        for item_id in selected_items:
            song_id = tree.item(item_id)["values"][1]
            if custom_songs:
                combined_items = custom_music_info["items"] + music_info["items"]
            else:
                combined_items = music_info["items"]
    
            song_info = next((item for item in combined_items if item["id"] == song_id), None)

            if song_info:

                # Calculate song_order based on genreNo and current_unique_id
                song_order = (int(song_info["genreNo"]) * 1000) + current_unique_id

                if game_platform == "WIIU3":

                    pattern = r"^cs\d{4}$"

                    if re.match(pattern, song_info["id"]):
                        custom_songs == True
                    else:
                        custom_songs == False

                    def convert_song_wiiu(song_id, custom_songs):

                        preview_pos = get_preview_pos(song_id)

                        if custom_songs == True:
                            custom_preview_pos = get_preview_pos(song_id)

                        if custom_songs == True:
                            song_filename = os.path.join(custom_data_dir, "sound", f"song_{song_id}.mp3")
                        else:
                            song_filename = os.path.join(data_dir, "sound", f"song_{song_id}.mp3")

                        output_file = os.path.join(audio_output_dir, f"song_{song_id}.nus3bank")

                        convert_audio_to_nus3bank(song_filename, "idsp", platform_tag, str(preview_pos), song_id)

                        if os.path.exists(f"song_{song_id}.nus3bank"):
                            shutil.move(f"song_{song_id}.nus3bank", output_file)
                            print(f"Created {output_file} successfully.")
                        else:
                            print(f"Conversion failed for song_{song_id}.")
                        if os.path.exists(f"song_{song_id}.mp3.idsp"):
                            os.remove(f"song_{song_id}.mp3.idsp")
                            print(f"Deleted song_{song_id}.mp3.idsp")  

                    formatted_id = f"{current_unique_id:04d}"
                    output_dir = f"out/content/{formatted_id}/musicInfo"
                    fumen_output_dir = f"out/content/{formatted_id}/fumen"
                    audio_output_dir = f"out/content/{formatted_id}/sound"
                    texture_output_dir = f"out/content/{formatted_id}/texture"     

                    os.makedirs(output_dir, exist_ok=True)
                    os.makedirs(fumen_output_dir, exist_ok=True)
                    os.makedirs(audio_output_dir, exist_ok=True)

                    easy_value = int(song_info["starEasy"])
                    normal_value = int(song_info["starNormal"])
                    hard_value = int(song_info["starHard"])
                    extreme_value = int(song_info["starMania"]) 

                    if easy_value == 0 and normal_value == 0 and hard_value == 0 and extreme_value > 0:
                        print("Extreme Only Chart Detected")
                        wiiu3_song_info_xml = create_wiiu3_song_info_extreme_xml(song_info, current_unique_id, song_order, word_list)
                    elif easy_value == 0 and normal_value == 0 and extreme_value == 0 and hard_value > 0:
                        print("Hard Only Chart Detected") # this exists literally only for zzff14 lmao
                        wiiu3_song_info_xml = create_wiiu3_song_info_hard_xml(song_info, current_unique_id, song_order, word_list)
                    else:    
                        wiiu3_song_info_xml = create_wiiu3_song_info_xml(song_info, current_unique_id, song_order, word_list)

                    root.append(wiiu3_song_info_xml)

                    if re.match(pattern, song_info["id"]):
                        custom_songs == True
                        generate_wiiu3_texture(song_info["id"], song_info["genreNo"], current_unique_id, append_ura=False, custom_songs=True)
                    else:
                        custom_songs == False
                        generate_wiiu3_texture(song_info["id"], song_info["genreNo"], current_unique_id, append_ura=False, custom_songs=False)

                    file_path = f"out/content/{formatted_id}/musicInfo/musicinfo_db"
                    root.set('num', str(db_data_count))
                    save_xml_to_file(root, file_path)

                    if re.match(pattern, song_info["id"]):
                        custom_songs == True
                        copy_fumens_custom()
                    else:
                        custom_songs == False
                        copy_fumens()
                        
    
                    print(f"XML file saved to {file_path}")
                    process_music_info(current_unique_id)
                    print(f"DRP File generated")
                    process_fumens_files(fumen_output_dir)
                    print(f"Converted fumen files to big endian.")

                    input_folder = os.path.join(texture_output_dir, song_info["id"],)
                    output_file = os.path.join(texture_output_dir, f"{song_info['id']}.nut")
                    generate_nut_texture(input_folder, output_file)

                    if re.match(pattern, song_info["id"]):
                        custom_songs == True
                        convert_song_wiiu(song_id, custom_songs=True)
                    else:
                        custom_songs == False
                        convert_song_wiiu(song_id, custom_songs=False)

                    root.clear()

                    cleanup_fumen_output_dir(fumen_output_dir)
                    remove_musicinfo_leftover(output_dir)
                    remove_texture_leftover(texture_output_dir)

                    ura_value = int(song_info["starUra"])

                    if ura_value > 0:            

                        current_unique_id += 1
                        print(ura_value)

                        formatted_id = f"{current_unique_id:04d}"
                        output_dir = f"out/content/{formatted_id}/musicInfo"
                        fumen_output_dir = f"out/content/{formatted_id}/fumen"
                        audio_output_dir = f"out/content/{formatted_id}/sound"
                        texture_output_dir = f"out/content/{formatted_id}/texture"     

                        os.makedirs(output_dir, exist_ok=True)
                        os.makedirs(fumen_output_dir, exist_ok=True)
                        os.makedirs(audio_output_dir, exist_ok=True)

                        wiiu3_song_info_xml = create_wiiu3_song_info_ura_xml(song_info, current_unique_id, song_order, word_list)
                        root.append(wiiu3_song_info_xml)
                        if re.match(pattern, song_info["id"]):
                            custom_songs == True
                            generate_wiiu3_texture(song_info["id"], song_info["genreNo"], current_unique_id, append_ura=True, custom_songs=True)
                        else:
                            custom_songs == False
                            generate_wiiu3_texture(song_info["id"], song_info["genreNo"], current_unique_id, append_ura=True, custom_songs=False)

                        file_path = f"out/content/{formatted_id}/musicInfo/musicinfo_db"
                        root.set('num', str(db_data_count))
                        save_xml_to_file(root, file_path)

                        copy_fumens_ura()

                        print(f"XML file saved to {file_path}")
                        process_music_info(current_unique_id)
                        print(f"DRP File generated")
                        process_fumens_files(fumen_output_dir)
                        print(f"Converted fumen files to big endian.")
                        
                        input_folder = os.path.join(texture_output_dir, song_info["id"],)
                        output_file = os.path.join(texture_output_dir, f"ex_{song_info['id']}.nut")
                        generate_nut_texture(input_folder, output_file)
          
                        if re.match(pattern, song_info["id"]):
                            custom_songs == True
                            convert_song_wiiu(song_id, custom_songs=True)
                        else:
                            custom_songs == False
                            convert_song_wiiu(song_id, custom_songs=False)         

                        root.clear()    

                        cleanup_fumen_output_dir(fumen_output_dir)
                        remove_musicinfo_leftover(output_dir)
                        remove_texture_leftover(texture_output_dir)                          

                    if re.match(pattern, song_info["id"]):
                        custom_songs == True
                    else:
                        custom_songs == False

                elif game_platform == "NS1":
                    ns1_song_info = {
                        "id": song_info["id"],
                        "uniqueId": current_unique_id,
                        "songFileName": song_info["songFileName"],
                        "order": song_order,
                        "genreNo": song_info["genreNo"],
		                "secretFlag":False,
                		"dlc":False,
                		"debug":False,
		                "recording":True,
                        "branchEasy": song_info["branchEasy"],
                        "branchNormal": song_info["branchNormal"],
                        "branchHard": song_info["branchHard"],
                        "branchMania": song_info["branchMania"],
                        "branchUra": song_info["branchUra"],
                        "starEasy": song_info["starEasy"],
                        "starNormal": song_info["starNormal"],
                        "starHard": song_info["starHard"],
                        "starMania": song_info["starMania"],
                        "starUra": song_info["starUra"],
                        "shinutiEasy": song_info["shinutiEasy"],
                        "shinutiNormal": song_info["shinutiNormal"],
                        "shinutiHard": song_info["shinutiHard"],
                        "shinutiMania": song_info["shinutiMania"],
                        "shinutiUra": song_info["shinutiUra"],
                        "shinutiEasyDuet": song_info["shinutiEasyDuet"],
                        "shinutiNormalDuet": song_info["shinutiNormalDuet"],
                        "shinutiHardDuet": song_info["shinutiHardDuet"],
                        "shinutiManiaDuet": song_info["shinutiManiaDuet"],
                        "shinutiUraDuet": song_info["shinutiUraDuet"],
                        "scoreEasy": song_info["scoreEasy"],
                        "scoreNormal": song_info["scoreNormal"],
                        "scoreHard": song_info["scoreHard"],
                        "scoreMania": song_info["scoreMania"],
                        "scoreUra": song_info["scoreUra"],
                        "alleviationEasy": False,
                        "alleviationNormal": False,
                        "alleviationHard": False,
                        "alleviationMania": False,
                        "alleviationUra": False,
                        "song_info1": 25721,
                        "song_info2": 39634,
                        "song_info3": 60504,
                        "song_info4": 79618,
                        "song_info5": 98750,
                        "song_info6": -1,
                        "song_info7": -1,
                        "song_info8": -1,
                        "song_info9": -1,
                        "song_info10": -1,
                        "aocID": song_info["id"],
                        "limitedID": -1,
                        "extraID": -1,
                        "tournamentRand": True,
                        "bgDon0": "",
                        "bgDancer0": "",
                        "bgFever0": "",
                        "chibi0": "",
                        "rendaEffect0": "",
                        "dancer0": "",
                        "feverEffect0": "",
                        "bgDon1": "",
                        "bgDancer1": "",
                        "bgFever1": "",
                        "chibi1": "",
                        "rendaEffect1": "",
                        "dancer1": "",
                        "feverEffect1": "",
                    }
                    selected_music_info.append(ns1_song_info)
                elif game_platform == "PS4":
                    ps4_song_info = {
                        "id": song_info["id"],
                        "uniqueId": current_unique_id,                       
                        "songFileName": song_info["songFileName"],
                        "order": song_order,
                        "genreNo": song_info["genreNo"],
		                "secretFlag":False,
	                	"dlc":False,
	                	"entitlementKey":"",
	                	"secondKey":False,
	                	"entitlementKey2":"",
	                	"debug":False,
                        "branchEasy": song_info["branchEasy"],
                        "branchNormal": song_info["branchNormal"],
                        "branchHard": song_info["branchHard"],
                        "branchMania": song_info["branchMania"],
                        "branchUra": song_info["branchUra"],
                        "starEasy": song_info["starEasy"],
                        "starNormal": song_info["starNormal"],
                        "starHard": song_info["starHard"],
                        "starMania": song_info["starMania"],
                        "starUra": song_info["starUra"],
                        "shinutiEasy": song_info["shinutiEasy"],
                        "shinutiNormal": song_info["shinutiNormal"],
                        "shinutiHard": song_info["shinutiHard"],
                        "shinutiMania": song_info["shinutiMania"],
                        "shinutiUra": song_info["shinutiUra"],
                        "shinutiEasyDuet": song_info["shinutiEasyDuet"],
                        "shinutiNormalDuet": song_info["shinutiNormalDuet"],
                        "shinutiHardDuet": song_info["shinutiHardDuet"],
                        "shinutiManiaDuet": song_info["shinutiManiaDuet"],
                        "shinutiUraDuet": song_info["shinutiUraDuet"],
                        "scoreEasy": song_info["scoreEasy"],
                        "scoreNormal": song_info["scoreNormal"],
                        "scoreHard": song_info["scoreHard"],
                        "scoreMania": song_info["scoreMania"],
                        "scoreUra": song_info["scoreUra"],
		                "secret":False,
	                	"songFileNameForSelect": song_info["songFileName"],
	                	"bgSolo0":"",
	                	"bgDuet0":"",
	                	"chibi0":"",
	                	"rendaEffect0":"",
	                	"dancer0":"",
	                	"feverEffect0":"",
	                	"bgSolo1":"",
	                	"bgDuet1":"",
                        "chibi1":"",
                        "rendaEffect1":"",
	                	"dancer1":"",
	                	"feverEffect1":""
                    }
                    selected_music_info.append(ps4_song_info)
                elif game_platform == "PTB":
                    ptb_song_info = {
                        "uniqueId": current_unique_id,                       
                        "id": song_info["id"],
                        "songFileName": song_info["songFileName"],
                        "order": song_order,
                        "genreNo": song_info["genreNo"],
		                "isLock":False,
	                	"isNew":False,
	                	"debug":False,
	                	"temp":False,
	                	"temp2":False,
                        "branchEasy": song_info["branchEasy"],
                        "branchNormal": song_info["branchNormal"],
                        "branchHard": song_info["branchHard"],
                        "branchMania": song_info["branchMania"],
                        "branchUra": song_info["branchUra"],
                        "starEasy": song_info["starEasy"],
                        "starNormal": song_info["starNormal"],
                        "starHard": song_info["starHard"],
                        "starMania": song_info["starMania"],
                        "starUra": song_info["starUra"],
                        "shinutiEasy": song_info["shinutiEasy"],
                        "shinutiNormal": song_info["shinutiNormal"],
                        "shinutiHard": song_info["shinutiHard"],
                        "shinutiMania": song_info["shinutiMania"],
                        "shinutiUra": song_info["shinutiUra"],
                        "shinutiEasyDuet": song_info["shinutiEasyDuet"],
                        "shinutiNormalDuet": song_info["shinutiNormalDuet"],
                        "shinutiHardDuet": song_info["shinutiHardDuet"],
                        "shinutiManiaDuet": song_info["shinutiManiaDuet"],
                        "shinutiUraDuet": song_info["shinutiUraDuet"],
                        "scoreEasy": song_info["scoreEasy"],
                        "scoreNormal": song_info["scoreNormal"],
                        "scoreHard": song_info["scoreHard"],
                        "scoreMania": song_info["scoreMania"],
                        "scoreUra": song_info["scoreUra"],
                    }
                    selected_music_info.append(ptb_song_info)

                    # Find previewPos from previewpos.json based on song_id
                    preview_pos = None
                    for item in previewpos_data:
                        if item["id"] == song_info["id"]:
                            preview_pos = item["previewPos"]
                            break

                    ptb_extra_song_info = {
                        "uniqueId": current_unique_id,                       
                        "id": song_info["id"],
                        "previewPos": preview_pos if preview_pos is not None else 0,  # Use 0 if previewPos not found
		                "fumenOffsetPos":0
                    }
                    selected_song_info.append(ptb_extra_song_info)
                current_unique_id += 1
                if game_platform == "WIIU3":
                    db_data_count += 1

                # Find the wordlist items corresponding to song variations
                word_keys = [f"song_{song_id}", f"song_sub_{song_id}", f"song_detail_{song_id}"]
                
                def find_word_info(key, word_lists):
                    for word_list in word_lists:
                        word_info = next((item for item in word_list["items"] if item["key"] == key), None)
                        if word_info:
                            return word_info
                    return None
                
                word_lists = [word_list]
                if custom_songs:
                    word_lists.append(custom_word_list)
                
                for key in word_keys:
                    word_info = find_word_info(key, word_lists)
                    if word_info:
                        selected_wordlist.append(word_info)

                if game_platform == "PS4":
                    # Find the corresponding preview position for the current song_id
                    preview_pos = next((item["previewPos"] for item in previewpos_data if item["id"] == song_id), None)
                    if custom_songs:
                        custom_preview_pos = next((item["previewPos"] for item in custom_previewpos_data if item["id"] == song_id), None)

                    def convert_song(song_id, custom_songs):
                        preview_pos = get_preview_pos(song_id)
                        if custom_songs and custom_preview_pos is not None:
                            song_filename = os.path.join(custom_data_dir, "sound", f"song_{song_id}.mp3")
                        else:
                            song_filename = os.path.join(data_dir, "sound", f"song_{song_id}.mp3")

                        output_file = os.path.join(audio_output_dir, f"song_{song_id}.nus3bank")

                        if audio_quality == "low":
                            convert_audio_to_nus3bank(song_filename, "bnsf", platform_tag, str(preview_pos), song_id)
                        else: 
                            convert_audio_to_nus3bank(song_filename, "at9", platform_tag, str(preview_pos), song_id)
                        if os.path.exists(f"song_{song_id}.nus3bank"):
                            shutil.move(f"song_{song_id}.nus3bank", output_file)
                            print(f"Created {output_file} successfully.")
                        else:
                            print(f"Conversion failed for song_{song_id}.")
                        if os.path.exists(f"song_{song_id}.mp3.at9"):
                            os.remove(f"song_{song_id}.mp3.at9")
                            print(f"Deleted song_{song_id}.mp3.at9")

                    # Check if preview_pos or custom_preview_pos is not None and run conversion
                    if preview_pos is not None or (custom_songs and custom_preview_pos is not None):
                        convert_song(song_id, custom_songs)                    
                        
                elif game_platform == "PTB":
                    # Find the corresponding preview position for the current song_id
                    preview_pos = next((item["previewPos"] for item in previewpos_data if item["id"] == song_id), None)
                    if custom_songs:
                        custom_preview_pos = next((item["previewPos"] for item in custom_previewpos_data if item["id"] == song_id), None)

                    def convert_song(song_id, custom_songs):
                        preview_pos = get_preview_pos(song_id)
                        if custom_songs and custom_preview_pos is not None:
                            song_filename = os.path.join(custom_data_dir, "sound", f"song_{song_id}.mp3")
                        else:
                            song_filename = os.path.join(data_dir, "sound", f"song_{song_id}.mp3")                        
                        output_file = os.path.join(audio_output_dir, f"song_{song_id}.bin")
                        create_and_encrypt_acb(song_filename, song_id)
                        shutil.move(f"song_{song_id}.bin", output_file)     

                    # Check if preview_pos or custom_preview_pos is not None and run conversion
                    if preview_pos is not None or (custom_songs and custom_preview_pos is not None):
                        convert_song(song_id, custom_songs)                                                          

                elif game_platform == "NS1":
                    # Find the corresponding preview position for the current song_id
                    preview_pos = next((item["previewPos"] for item in previewpos_data if item["id"] == song_id), None)
                    if custom_songs:
                        custom_preview_pos = next((item["previewPos"] for item in custom_previewpos_data if item["id"] == song_id), None)

                    def convert_song(song_id, custom_songs):
                        preview_pos = get_preview_pos(song_id)
                        if custom_songs and custom_preview_pos is not None:
                            song_filename = os.path.join(custom_data_dir, "sound", f"song_{song_id}.mp3")
                        else:
                            song_filename = os.path.join(data_dir, "sound", f"song_{song_id}.mp3")

                        output_file = os.path.join(audio_output_dir, f"song_{song_id}.nus3bank")

                        if audio_quality == "low":
                            convert_audio_to_nus3bank(song_filename, "bnsf", platform_tag, str(preview_pos), song_id)
                        else:
                            convert_audio_to_nus3bank(song_filename, "idsp", platform_tag, str(preview_pos), song_id)

                        if os.path.exists(f"song_{song_id}.nus3bank"):
                            shutil.move(f"song_{song_id}.nus3bank", output_file)
                            print(f"Created {output_file} successfully.")
                        else:
                            print(f"Conversion failed for song_{song_id}.")
                        if os.path.exists(f"song_{song_id}.mp3.idsp"):
                            os.remove(f"song_{song_id}.mp3.idsp")
                            print(f"Deleted song_{song_id}.mp3.idsp")

                    # Check if preview_pos or custom_preview_pos is not None and run conversion
                    if preview_pos is not None or (custom_songs and custom_preview_pos is not None):
                        convert_song(song_id, custom_songs)

        # Export selected musicinfo and wordlist
        if game_platform == "PTB":

            selected_musicinfo_path = os.path.join(output_dir, musicinfo_filename)
            selected_wordlist_path = os.path.join(output_dir, "wordlist.json")
            selected_songinfo_path = os.path.join(output_dir, songinfo_filename) 

            with open(selected_songinfo_path, "w", encoding="utf-8") as out_musicinfo_file:
                json.dump({"items": selected_song_info}, out_musicinfo_file, ensure_ascii=False, indent=4)

            with open(selected_musicinfo_path, "w", encoding="utf-8") as out_musicinfo_file:
                json.dump({"items": selected_music_info}, out_musicinfo_file, ensure_ascii=False, indent=4)

            with open(selected_wordlist_path, "w", encoding="utf-8") as out_wordlist_file:
                json.dump({"items": selected_wordlist}, out_wordlist_file, ensure_ascii=False, indent=4)

            merge_ptb('data\\_console\\Raw\\ReadAssets\\wordlist.json', 'out\\Data\\Raw\\ReadAssets\\wordlist.json', 'out\\Data\\Raw\\ReadAssets\\wordlist.json')

            #Compress each ReadAsset file
            gzip_compress_file(selected_musicinfo_path)
            gzip_compress_file(selected_wordlist_path)
            gzip_compress_file(selected_songinfo_path)

            #Compress each Remove the json files
            os.remove(selected_musicinfo_path)
            os.remove(selected_wordlist_path)
            os.remove(selected_songinfo_path)

            #Compressed File definitions
            compressed_musicinfo_path = os.path.join(output_dir, "musicinfo.gz")
            compressed_wordlist_path = os.path.join(output_dir, "wordlist.gz")
            compressed_songinfo_path = os.path.join(output_dir, "songinfo.gz")             

            # Final Output definitions
            final_musicinfo = os.path.join(output_dir, "musicinfo.bin")
            final_wordlist = os.path.join(output_dir, "wordlist.bin")
            final_songinfo = os.path.join(output_dir, "songinfo.bin")    

            # Encrypt the final files
            encrypt_file_ptb(compressed_musicinfo_path, final_musicinfo)
            encrypt_file_ptb(compressed_wordlist_path, final_wordlist)
            encrypt_file_ptb(compressed_songinfo_path, final_songinfo)   

            # Remove compressed .gz files
            os.remove(compressed_musicinfo_path)
            os.remove(compressed_wordlist_path)
            os.remove(compressed_songinfo_path)                                

        elif game_platform == "PS4":

            selected_musicinfo_path = os.path.join(output_dir, musicinfo_filename)
            selected_wordlist_path = os.path.join(output_dir, "wordlist.json")

            with open(selected_musicinfo_path, "w", encoding="utf-8") as out_musicinfo_file:
                json.dump({"items": selected_music_info}, out_musicinfo_file, ensure_ascii=False, indent=4)

            with open(selected_wordlist_path, "w", encoding="utf-8") as out_wordlist_file:
                json.dump({"items": selected_wordlist}, out_wordlist_file, ensure_ascii=False, indent=4)            

            if game_region == "JPN/ASIA":
                merge_ps4_jp('data\\_console\\ORBIS\\datatablejp\\wordlist.json', 'out\\Data\\ORBIS\\datatable\\wordlist.json', 'out\\Data\\ORBIS\\datatable\\wordlist.json')
            elif game_region == "EU/USA":
                merge_ps4_int('data\\_console\\ORBIS\\datatableint\\wordlist.json', 'out\\Data\\ORBIS\\datatable\\wordlist.json', 'out\\Data\\ORBIS\\datatable\\wordlist.json')

            #Compress each datatable file
            gzip_compress_file_ps4(selected_musicinfo_path)
            gzip_compress_file_ps4(selected_wordlist_path)

            #Remove .json files
            os.remove(selected_musicinfo_path)
            os.remove(selected_wordlist_path)

            copy_folder(fumen_output_dir,fumen_hitwide_output_dir)

        elif game_platform == "NS1":
            
            selected_musicinfo_path = os.path.join(output_dir, musicinfo_filename)
            selected_wordlist_path = os.path.join(output_dir, "wordlist.json")

            with open(selected_musicinfo_path, "w", encoding="utf-8") as out_musicinfo_file:
                json.dump({"items": selected_music_info}, out_musicinfo_file, ensure_ascii=False, indent=4)

            with open(selected_wordlist_path, "w", encoding="utf-8") as out_wordlist_file:
                json.dump({"items": selected_wordlist}, out_wordlist_file, ensure_ascii=False, indent=4)            

            if game_region == "JPN/ASIA":
                merge_ns1_jp('data\\_console\\NX\\datatable\\wordlist.json', 'out\\Data\\NX\\datatable\\wordlist.json', 'out\\Data\\NX\\datatable\\wordlist.json')
            elif game_region == "EU/USA":
                merge_ns1_int('data\\_console\\NX\\datatable\\wordlist.json', 'out\\Data\\NX\\datatable\\wordlist.json', 'out\\Data\\NX\\datatable\\wordlist.json')


            #Compress each datatable file
            gzip_compress_file(selected_musicinfo_path)
            gzip_compress_file(selected_wordlist_path)

            #Compress each Remove the json files
            os.remove(selected_musicinfo_path)
            os.remove(selected_wordlist_path)

            #Compressed File definitions
            compressed_musicinfo_path = os.path.join(output_dir, "musicinfo.gz")
            compressed_wordlist_path = os.path.join(output_dir, "wordlist.gz")        

            # Final Output definitions
            final_musicinfo = os.path.join(output_dir, "musicinfo.bin")
            final_wordlist = os.path.join(output_dir, "wordlist.bin")

            # Encrypt the final files
            encrypt_file_ns1(compressed_musicinfo_path, final_musicinfo)
            encrypt_file_ns1(compressed_wordlist_path, final_wordlist)

            # Remove compressed .gz files
            os.remove(compressed_musicinfo_path)
            os.remove(compressed_wordlist_path)

            copy_folder(fumen_output_dir,fumen_hitwide_output_dir)
            copy_folder(fumen_output_dir,fumen_hitnarrow_output_dir)

        messagebox.showinfo("Export Completed", "Selected songs exported successfully!")

    except Exception as e:
        messagebox.showerror("Export Error", f"An error occurred during export: {str(e)}")

#Button shenanigans, because the order they appear on the gui, is determined by the literal order they are in the code???

# Top Side

if lang == "jp":
    preview_button = ttk.Button(main_frame, text="オーディオ・プレビュー", command=preview_selected)
else:
    preview_button = ttk.Button(main_frame, text="Preview", command=preview_selected)
preview_button.pack(side="top", padx=20, pady=10)

# Create sorting options
if lang == "jp":
    sort_options = ["ID", "Song Name", "Genre"]
    sort_label = tk.Label(main_frame, text="ソートフィルター：")
else:
    sort_options = ["ID", "Song Name", "Genre"]
    sort_label = tk.Label(main_frame, text="Sort by:")
sort_label.pack(side="top", padx=20, pady=5)

sort_var = tk.StringVar(main_frame)
sort_var.set("ID")
sort_menu = ttk.Combobox(main_frame, textvariable=sort_var, values=sort_options)
sort_menu.bind("<<ComboboxSelected>>", lambda _: sort_tree(sort_var.get()))
sort_menu.pack(side="top", padx=20, pady=0)

search_entry.pack(side="top", padx=20, pady=10, fill="x") # search bar, currently broken

# Bottom Side

if lang == "jp":
    clear_button = ttk.Button(main_frame, text="クリア・セレクション", command=clear_selection)
else:
    clear_button = ttk.Button(main_frame, text="Clear Selection", command=clear_selection)
clear_button.pack(side="bottom", padx=20, pady=10)

if lang == "jp":
    export_button = ttk.Button(main_frame, text="エクスポート", command=export_data)
else:
    export_button = ttk.Button(main_frame, text="Export", command=export_data)    
export_button.pack(side="bottom", padx=20, pady=10)

# Create Selection Count Label
selection_count_label = ttk.Label(main_frame, text="0/???")
selection_count_label.pack(side="bottom", padx=20, pady=10)

# Game platform selection
game_platform_var = tk.StringVar(main_frame)
game_platform_var.set("PS4")
game_platform_choices = ["PS4", "NS1", "WIIU3", "PTB"]
game_platform_menu = ttk.Combobox(main_frame, textvariable=game_platform_var, values=game_platform_choices)
game_platform_menu.pack(side="bottom", padx=20, pady=0)

# Create Label for Platform selection
if lang == "jp":
    platform_label = tk.Label(main_frame, text="ゲーム機：")
else:
    platform_label = tk.Label(main_frame, text="Platform")
platform_label.pack(side="bottom", padx=20, pady=5)

# Game region selection, needed for wordlist export
game_region_var = tk.StringVar(main_frame)
game_region_var.set("JPN/ASIA")
game_region_choices = ["JPN/ASIA", "EU/USA"]
game_region_menu = ttk.Combobox(main_frame, textvariable=game_region_var, values=game_region_choices)
game_region_menu.pack(side="bottom", padx=20, pady=10)

# Create Label for Region selection
if lang == "jp":
    game_region_label = tk.Label(main_frame, text="ゲーム地域：")
else:
    game_region_label = tk.Label(main_frame, text="Game Region:")
game_region_label.pack(side="bottom", padx=20, pady=0)

window.mainloop()