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(
            ("Generating a new UE project ... 1 out of "
             f"{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_filename = cmdlet_project.name
        cmdlet_dir = cmdlet_project.parent.as_posix()
        cmdlet_tmp_name = Path(cmdlet_tmp.name)
        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 "
                 f"{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!")