main.py

import os
import random
import shutil
from pathlib import Path

from PyQt6.QtCore import pyqtSignal, QThread
from PyQt6.QtWidgets import (QApplication, QWizard, QWizardPage, QVBoxLayout,
                             QLabel, QLineEdit, QPushButton, QFileDialog, QMessageBox, QProgressBar)

# Constants
TEMPLATE_PATH = Path('template')
OUTPUT_DIR = Path('generated')
MODS_DIR = Path('mods')
BLOCK_TEXTURES = list((TEMPLATE_PATH / 'blocks').glob('*.png'))
ITEM_TEXTURES = list((TEMPLATE_PATH / 'items').glob('*.png'))

currentId = 0


class IntroPage(QWizardPage):
    def __init__(self):
        super().__init__()
        self.setTitle("Introduction")
        layout = QVBoxLayout()
        layout.addWidget(QLabel("Welcome to the Mod Generator Wizard."))
        self.setLayout(layout)


class ModInfoPage(QWizardPage):
    def __init__(self):
        super().__init__()
        self.setTitle("Mod Information")
        layout = QVBoxLayout()

        self.mod_count_label = QLabel("Number of Mods:")
        self.mod_count_input = QLineEdit()
        self.mod_count_input.setPlaceholderText("Enter number of mods to generate")

        layout.addWidget(self.mod_count_label)
        layout.addWidget(self.mod_count_input)
        self.setLayout(layout)

    def validatePage(self):
        try:
            value = int(self.mod_count_input.text())
            self.wizard().setProperty("mod_count", value)
            return True
        except ValueError:
            QMessageBox.warning(self, "Input Error", "Please enter a valid number.")
            return False


class OutputDirPage(QWizardPage):
    def __init__(self):
        super().__init__()
        self.setTitle("Output Directory")
        layout = QVBoxLayout()

        self.output_dir_label = QLabel("Select Output Directory:")
        self.output_dir_button = QPushButton("Choose Directory")
        self.output_dir_button.clicked.connect(self.select_output_directory)

        layout.addWidget(self.output_dir_label)
        layout.addWidget(self.output_dir_button)
        self.setLayout(layout)

    def select_output_directory(self):
        directory = QFileDialog.getExistingDirectory(self, "Select Directory")
        if directory:
            global OUTPUT_DIR
            OUTPUT_DIR = Path(directory)


class SummaryPage(QWizardPage):
    def __init__(self):
        super().__init__()
        self.setTitle("Summary")
        self.final_message = QLabel()
        self.progress_bar = QProgressBar()
        self.progress_bar.setMaximum(100)

        layout = QVBoxLayout()
        layout.addWidget(self.final_message)
        layout.addWidget(self.progress_bar)
        self.setLayout(layout)

    def initializePage(self):
        mod_count = int(self.wizard().property("mod_count"))
        self.final_message.setText(f"Generating {mod_count} mods in directory: {OUTPUT_DIR}")
        self.worker = ModGeneratorWorker(mod_count)
        self.worker.progress.connect(self.update_progress)
        self.worker.start()

    def update_progress(self, value):
        mod_count = int(self.wizard().property("mod_count"))
        progress_percent = int((value / mod_count) * 100)
        self.progress_bar.setValue(progress_percent)
        if value == mod_count:
            QMessageBox.information(self.window(), "Success", "Mods generated successfully!")


class ModGeneratorWorker(QThread):
    progress = pyqtSignal(int)

    def __init__(self, num_mods):
        super().__init__()
        self.num_mods = num_mods

    def run(self):
        for i in range(1, self.num_mods + 1):
            create_mod_project(i)
            self.progress.emit(i)


def create_mod_project(mod_number: int):
    mod_id = f'id{mod_number}'
    mod_path = OUTPUT_DIR / mod_id

    shutil.rmtree(mod_path, ignore_errors=True)
    shutil.copytree(TEMPLATE_PATH / 'base', mod_path)

    # Rename package directory from `base` to `id<number>`
    old_package_path = mod_path / 'src' / 'main' / 'java' / 'dev' / 'ultreon' / 'base'
    new_package_path = mod_path / 'src' / 'main' / 'java' / 'dev' / 'ultreon' / mod_id
    old_package_path.rename(new_package_path)

    # Rename package directory in Kotlin source if it exists
    old_kotlin_package_path = mod_path / 'src' / 'main' / 'kotlin' / 'dev' / 'ultreon' / 'base'
    if old_kotlin_package_path.exists():
        new_kotlin_package_path = mod_path / 'src' / 'main' / 'kotlin' / 'dev' / 'ultreon' / mod_id
        old_kotlin_package_path.rename(new_kotlin_package_path)

    # Update package declarations in Java and Kotlin files
    for root, _, files in os.walk(mod_path / 'src' / 'main'):
        for file in files:
            if file.endswith('.java') or file.endswith('.kt'):
                file_path = os.path.join(root, file)
                with open(file_path, 'r') as f:
                    content = f.read()
                updated_content = content.replace('dev.ultreon.base', f'dev.ultreon.{mod_id}')
                with open(file_path, 'w') as f:
                    f.write(updated_content)

    # Modify Blocks.java
    blocks_path = mod_path / 'src' / 'main' / 'java' / 'dev' / 'ultreon' / mod_id / 'blocks' / 'Blocks.java'
    os.makedirs(blocks_path.parent, exist_ok=True)

    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'blockstates', exist_ok=True)
    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'items', exist_ok=True)
    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'models' / 'block', exist_ok=True)
    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'models' / 'item', exist_ok=True)
    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'textures' / 'block', exist_ok=True)
    os.makedirs(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'textures' / 'item', exist_ok=True)

    contents = ""
    for i in range(random.randint(5, 40)):
        contents += f"        createBlock(\"id_{i}_block\");\n"
        block_texture = random.choice(BLOCK_TEXTURES)

        with open(block_texture, 'rb') as texture_file:
            texture_data = texture_file.read()

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'textures' / 'block' / f'id_{i}_block.png', 'wb') as output_file:
            output_file.write(texture_data)
            output_file.flush()

        del texture_data

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'blockstates' / f'id_{i}_block.json', 'w+') as output_file:
            output_file.write(f"""
                    {{
                          "variants": {{
                              "": {{
                                  "model": "{mod_id}:block/id_{i}_block"
                              }}
                          }}
                    }}
                    """)

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'models' / 'block' / f'id_{i}_block.json', 'w+') as output_file:
            output_file.write(f"""
                    {{
                        "parent": "minecraft:block/cube_all",
                        "textures": {{
                            "all": "{mod_id}:block/id_{i}_block"
                        }}
                    }}
                    """)
            output_file.flush()


        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'items' / f'id_{i}_block.json', 'w+') as output_file:
            output_file.write(f"""
                    {{
                        "model": {{
                            "type": "minecraft:model",
                            "model": "{mod_id}:block/id_{i}_block"
                        }}
                    }}
                    """)
            output_file.flush()

    random_content = f"""
        import static dev.ultreon.{mod_id}.content.Contents.createBlock; 
    
        /**
         * Random content for mod {mod_id}
         *
         * This file was automatically generated by the Mod Generator Wizard
         *
         * @see dev.ultreon.{mod_id}.content.Contents
         * @version {mod_number}
         * @author Mod Generator Wizard
         */
        public class Blocks {{
            public static void init() {{
        {contents}
            }}
        }}
        """

    with open(blocks_path, 'w') as blocks_file:
        blocks_file.write(f"package dev.ultreon.{mod_id}.blocks;\n\n{random_content}\n")

    # Modify Items.java
    items_path = mod_path / 'src' / 'main' / 'java' / 'dev' / 'ultreon' / mod_id / 'items' / 'Items.java'
    contents = ""
    for i in range(random.randint(5, 40)):
        is_food = random.choice(["true", "false"])
        contents += f"        createItem(\"id_{i}\", {is_food}, {random.randint(1, 20) if is_food == 'true' else 0}, {random.randrange(0, 50) / 10.0});\n"
        item_texture = random.choice(ITEM_TEXTURES)

        with open(item_texture, 'rb') as texture_file:
            texture_data = texture_file.read()

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'textures' / 'item' / f'id_{i}.png', 'wb+') as output_file:
            output_file.write(texture_data)
            output_file.flush()

        del texture_data

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'models' / 'item' / f'id_{i}.json', 'w+') as output_file:
            output_file.write(f"""
                    {{
                        "parent": "minecraft:item/generated",
                        "textures": {{
                            "layer0": "{mod_id}:item/id_{i}"
                        }}
                    }}
                    """)
            output_file.flush()

        with open(mod_path / 'src' / 'main' / 'resources' / 'assets' / mod_id / 'items' / f'id_{i}.json', 'w+') as output_file:
            output_file.write(f"""
                    {{
                        "model": {{
                            "type": "minecraft:model",
                            "model": "{mod_id}:item/id_{i}"
                        }}
                    }}
                    """)
            output_file.flush()
    item_content = f"""
        import static dev.ultreon.{mod_id}.content.Contents.createItem; 
    
        /**
         * Random content for mod {mod_id}
         * 
         * @see dev.ultreon.{mod_id}.content.Contents
         * @version {mod_number}
         * @author Mod Generator Wizard by Ultreon
         */
        public class Items {{
        
            public static void init() {{
        {contents}
            }}
        }}"""

    os.makedirs(mod_path / 'src' / 'main' / 'java' / 'dev' / 'ultreon' / mod_id / 'items', exist_ok=True)
    with open(items_path, 'w+') as items_file:
        items_file.write(f"package dev.ultreon.{mod_id}.items;\n\n{item_content}\n")

    # Replace mod id in gradle.properties
    gradle_properties_path = mod_path / 'gradle.properties'
    with open(gradle_properties_path, 'r') as gradle_properties_file:
        gradle_properties_content = gradle_properties_file.read()
    updated_gradle_properties_content = gradle_properties_content.replace('$$MOD_ID$$', mod_id)
    with open(gradle_properties_path, 'w') as gradle_properties_file:
        gradle_properties_file.write(updated_gradle_properties_content)

    # Replace entrypoint in src/main/resources/fabric.mod.json
    fabric_mod_json_path = mod_path / 'src' / 'main' / 'resources' / 'fabric.mod.json'
    if os.path.exists(fabric_mod_json_path):
        with open(fabric_mod_json_path, 'r') as fabric_mod_json_file:
            fabric_mod_json_content = fabric_mod_json_file.read()
        updated_fabric_mod_json_content = fabric_mod_json_content.replace('dev.ultreon.base', f'dev.ultreon.{mod_id}')
        with open(fabric_mod_json_path, 'w') as fabric_mod_json_file:
            fabric_mod_json_file.write(updated_fabric_mod_json_content)

    cwd = os.getcwd()
    os.chdir(mod_path)
    os.system("./gradlew build")
    os.chdir(cwd)

    # Copy jar
    os.makedirs("mods", exist_ok=True)
    shutil.copy(mod_path / 'build' / 'libs' / f'{mod_id}-0.1.0.jar', MODS_DIR / f'{mod_id}.jar')

    # Clean up
    shutil.rmtree(mod_path, ignore_errors=True)


class ModGeneratorWizard(QWizard):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("Mod Generator Wizard")
        self.setWizardStyle(QWizard.WizardStyle.AeroStyle if sys.platform == 'win32' else QWizard.WizardStyle.MacStyle)

        # Pages
        self.idChanged = (int)
        self.addPage(IntroPage())
        self.addPage(ModInfoPage())
        self.addPage(OutputDirPage())
        self.addPage(SummaryPage())


        # Fields
        self.setProperty("mod_count", 0)


if __name__ == '__main__':
    import sys

    app = QApplication(sys.argv)
    app.setApplicationName("Mod Generator Wizard")
    wizard = ModGeneratorWizard()
    wizard.show()
    sys.exit(app.exec())