from pathlib import Path
from multiprocessing import Pool, Manager, set_start_method
from log import Log, LogCat
from . import Worker


class Transcoder:
    def __init__(self, encoder: Path, extension: str, input_root: Path, output_root: Path, log_path: Path):
        self.encoder = encoder
        self.extension = extension
        self.input_root = input_root
        self.output_root = output_root

        self.log_path = log_path
        self.__log = Log(log_path)
        self.log = LogCat(self.__log.queue, "TCD")

    def transcode(self):
        transcode_list = []
        try:
            for artist in self.input_root.iterdir():
                if artist.is_dir():
                    for album in artist.iterdir():
                        if album.is_dir():
                            for file in album.iterdir():
                                if file.is_file():
                                    if file.name == "DONE":
                                        break
                                    else:
                                        transcode_list.append(file)
                        else:
                            self.log.warning("TRK", f"Warning, skipping non-dir '{album}' found in artist '{artist.parts[-1]}'")
                            continue
                else:
                    self.log.warning("TRK", f"Warning, skipping non-dir '{artist}' found in root")
                    continue
            self._transcode(transcode_list, self.encoder)
        finally:
            self.__log.stop()

    def _transcode(self, transcode_list: list, encoder: Path, workers=16):
        manager = Manager()
        queue = manager.Queue()
        log = Log(self.log_path, queue)
        logcat = LogCat(log.queue, "TCD")
        args = [(str(self.output_root), self.extension, track, encoder, logcat) for track in transcode_list]
        with Pool(workers) as pool:
            pool.starmap(self.worker, args)
            pool.close()
            pool.join()
        log.stop()

    def _transcode_single_thread(self, transcode_list: list, encoder: Path):
        log = Log(self.log_path)
        logcat = LogCat(log.queue, "TCD")
        worker_args = [(track, encoder) for track in transcode_list]
        for track, encoder in worker_args:
            self.worker(str(self.output_root), self.extension, track, encoder, logcat)
        log.stop()

    @staticmethod
    def worker(output_root, extension, track, encoder, log):
        w = Worker(output_root, extension)
        w.transcode_worker(track, encoder, log)