from abc import ABCMeta,abstractmethod

class Executor(metaclass=ABCMeta):
    @abstractmethod
    def deploy_env(self):
        pass

    @abstractmethod
    def init_env(self):
        pass

    @abstractmethod
    def get_case_code(self):
        pass

    @abstractmethod
    def suite2cases_resolver(self):
        pass

    @abstractmethod
    def run_all_cases(self):
        pass

    @abstractmethod
    def run_suite(self):
        pass

    @abstractmethod
    def run_case(self):
        pass


class LogResolver(metaclass=ABCMeta):
    @abstractmethod
    def loads_logs(self, log_lines):
        return log_lines

class Mugen:
    def _executor(self):
        return MugenExecutor()

class LTP:
    def _executor(self):
        return LtpExecutor()

class FrameWorkDict:
    mugen = Mugen
    ltp = LTP

class MugenExecutor:
    def deploy_env(self):
        pass

    def init_env(self):
        pass

    def get_case_code(self):
        pass

    def suite2cases_resolver(self):
        pass

    def run_all_cases(self):
        pass

    def run_suite(self):
        pass

    def run_case(self):
        print("mugen is ok")

class LtpExecutor:
    def deploy_env(self):
        pass

    def init_env(self):
        pass

    def get_case_code(self):
        pass

    def suite2cases_resolver(self):
        pass

    def run_all_cases(self):
        pass

    def run_suite(self):
        pass

    def run_case(self):
        print("ltp is ok ")

class LtpLogResolver:
    def loads_logs(self, log_lines):
        return log_lines

class MugenLogResolver:
    def loads_logs(self, log_lines):
        return log_lines

class ExecutorAdapter(Executor):

    def __init__(self, executor):
        self._executor=executor

    def deploy_env(self):
        self._executor.deploy_env()

    def init_env(self):
        self._executor.init_env()

    def get_case_code(self):
        self._executor.get_case_code()

    def suite2cases_resolver(self):
        self._executor.suite2cases_resolver()

    def run_all_cases(self):
        self._executor.run_all_cases()

    def run_suite(self):
        self._executor.run_suite()

    def run_case(self):
        self._executor.run_case()

# class LogResolverAdapt(LogResolver):
#     def __init__(self, logresolver):
#         self._logresolver=logresolver

class RunCaseHandler:
    def __init__(self, framework):
        self._framework = getattr(FrameWorkDict, framework)

    def work(self):
        self._executor = ExecutorAdapter(self._framework()._executor())
        self._executor.run_case()



if __name__ == "__main__":
 RunCaseHandler("ltp").work()