ue_workers

class UEProjectGenerationWorker(UEWorker):
    stage_begin = QtCore.Signal(str)

    ue_version: str = None
    project_name: str = None
    project_dir: Path = None
    dev_mode = False

    def setup(
        self,
        ue_version: str,
        project_name: str,
        unreal_project_name,
        engine_path: Path,
        project_dir: Path,
        dev_mode: bool = False,
        env: dict = None,
    ):
        """Set the worker with necessary parameters.

        Args:
            ue_version (str): Unreal Engine version.
            project_name (str): Name of the project in AYON.
            unreal_project_name (str): Name of the project in Unreal.
            engine_path (Path): Path to the Unreal Engine.
            project_dir (Path): Path to the project directory.
            dev_mode (bool, optional): Whether to run the project in dev mode.
                Defaults to False.
            env (dict, optional): Environment variables. Defaults to None.

        """

        self.ue_version = ue_version
        self.project_dir = project_dir
        self.env = env or os.environ

        preset = get_project_settings(project_name)["unreal"]["project_setup"]

        if dev_mode or preset["dev_mode"]:
            self.dev_mode = True

        self.project_name = unreal_project_name
        self.engine_path = engine_path

    def execute(self):
        # engine_path should be the location of UE_X.X folder

        ue_editor_exe = ue_lib.get_editor_exe_path(
            self.engine_path, self.ue_version
        )
        cmdlet_project = ue_lib.get_path_to_cmdlet_project(self.ue_version)
        project_file = self.project_dir / f"{self.project_name}.uproject"

        print("--- Generating a new project ...")
        # 1st stage
        stage_count = 2
        if self.dev_mode:
            stage_count = 4

        self.stage_begin.emit(
            (f"Generating a new UE project ... 1 out of {stage_count}")
        )

        # Need to copy the commandlet project to a temporary folder where
        # users don't need admin rights to write to.
        cmdlet_tmp = tempfile.TemporaryDirectory()
        cmdlet_tmp_str = cmdlet_tmp.name

        # Unreal engine can not handle dots in paths, so lets redirect
        # the temp folder when the username has a "."

        # OS agnostic diversion to home/Public, C:/Users/Public
        # on dot in username.
        user_dir = Path(os.path.expanduser("~"))

        if "." in user_dir.stem:
            cmdlet_tmp.cleanup()
            cmdlet_tmp_str.replace(
                str(user_dir), f"{user_dir.parent / 'Public'}"
            )
            Path(cmdlet_tmp_str).mkdir(parents=True, exist_ok=True)
            cmdlet_tmp.name = cmdlet_tmp_str

        cmdlet_filename = cmdlet_project.name
        cmdlet_dir = cmdlet_project.parent.as_posix()
        cmdlet_tmp_name = Path(cmdlet_tmp_str)

        cmdlet_tmp_file = cmdlet_tmp_name.joinpath(cmdlet_filename)
        copy_tree(cmdlet_dir, cmdlet_tmp_name.as_posix())

        commandlet_cmd = [
            f"{ue_editor_exe.as_posix()}",
            f"{cmdlet_tmp_file.as_posix()}",
            "-run=AyonGenerateProject",
            f"{project_file.resolve().as_posix()}",
        ]

        if self.dev_mode:
            commandlet_cmd.append("-GenerateCode")

        gen_process = subprocess.Popen(
            commandlet_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
        )

        for line in gen_process.stdout:
            decoded_line = line.decode(errors="replace")
            print(decoded_line, end="")
            self.log.emit(decoded_line)
        gen_process.stdout.close()
        return_code = gen_process.wait()

        cmdlet_tmp.cleanup()

        if return_code and return_code != 0:
            msg = (
                f"Failed to generate {self.project_name} "
                f"project! Exited with return code {return_code}"
            )
            self.failed.emit(msg, return_code)
            raise RuntimeError(msg)

        print("--- Project has been generated successfully.")
        self.stage_begin.emit(
            (
                f"Writing the Engine ID of the build UE ... 1"
                f" out of {stage_count}"
            )
        )

        if not project_file.is_file():
            msg = (
                "Failed to write the Engine ID into .uproject file! Can "
                "not read!"
            )
            self.failed.emit(msg)
            raise RuntimeError(msg)

        with open(project_file.as_posix(), mode="r+") as pf:
            pf_json = json.load(pf)
            pf_json["EngineAssociation"] = ue_lib.get_build_id(
                self.engine_path, self.ue_version
            )
            print(pf_json["EngineAssociation"])
            pf.seek(0)
            json.dump(pf_json, pf, indent=4)
            pf.truncate()
            print("--- Engine ID has been written into the project file")

        self.progress.emit(90)
        if self.dev_mode:
            # 2nd stage
            self.stage_begin.emit(
                (f"Generating project files ... 2 out of {stage_count}")
            )

            self.progress.emit(0)
            ubt_path = ue_lib.get_path_to_ubt(
                self.engine_path, self.ue_version
            )

            arch = "Win64"
            if platform.system().lower() == "windows":
                arch = "Win64"
            elif platform.system().lower() == "linux":
                arch = "Linux"
            elif platform.system().lower() == "darwin":
                # we need to test this out
                arch = "Mac"

            gen_prj_files_cmd = [
                ubt_path.as_posix(),
                "-projectfiles",
                f"-project={project_file}",
                "-progress",
            ]
            gen_proc = subprocess.Popen(
                gen_prj_files_cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
            )
            for line in gen_proc.stdout:
                decoded_line: str = line.decode(errors="replace")
                print(decoded_line, end="")
                self.log.emit(decoded_line)
                parse_prj_progress(decoded_line, self.progress)

            gen_proc.stdout.close()
            return_code = gen_proc.wait()

            if return_code and return_code != 0:
                msg = (
                    "Failed to generate project files! "
                    f"Exited with return code {return_code}"
                )
                self.failed.emit(msg, return_code)
                raise RuntimeError(msg)

            self.stage_begin.emit(
                f"Building the project ... 3 out of {stage_count}"
            )
            self.progress.emit(0)
            # 3rd stage
            build_prj_cmd = [
                ubt_path.as_posix(),
                f"-ModuleWithSuffix={self.project_name},3555",
                arch,
                "Development",
                "-TargetType=Editor",
                f"-Project={project_file}",
                f"{project_file}",
                "-IgnoreJunk",
            ]

            build_prj_proc = subprocess.Popen(
                build_prj_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
            )
            for line in build_prj_proc.stdout:
                decoded_line: str = line.decode(errors="replace")
                print(decoded_line, end="")
                self.log.emit(decoded_line)
                parse_comp_progress(decoded_line, self.progress)

            build_prj_proc.stdout.close()
            return_code = build_prj_proc.wait()

            if return_code and return_code != 0:
                msg = (
                    "Failed to build project! "
                    f"Exited with return code {return_code}"
                )
                self.failed.emit(msg, return_code)
                raise RuntimeError(msg)

        self.progress.emit(100)
        self.finished.emit("Project successfully built!")