from tests.support.paths import PROJECT_ROOT
import sys
from pathlib import Path
from types import SimpleNamespace


def load_server_module(name):
    addon_directory = PROJECT_ROOT / "src" / "anyimage"
    sys.path.insert(0, str(addon_directory))
    try:
        return __import__(f"server.{name}", fromlist=[name])
    finally:
        sys.path.remove(str(addon_directory))


def _make_fake_av(frame_count):
    """Build a fake av module yielding frame_count integer-valued frames."""
    class FakeImage:
        def __init__(self, value):
            self.value = value

        def save(self, path, format=None):
            Path(path).write_text(str(self.value), encoding="utf-8")

    class FakeFrame:
        def __init__(self, value):
            self.value = value

        def to_image(self):
            return FakeImage(self.value)

    class FakeContainer:
        def __init__(self):
            self.position = 0
            self.closed = False
            self.streams = SimpleNamespace(video=[object()])

        def decode(self, _stream):
            while self.position < frame_count:
                frame = FakeFrame(self.position)
                self.position += 1
                yield frame

        def close(self):
            self.closed = True

    class FakeAv:
        def __init__(self):
            self.containers = []

        def open(self, _path):
            container = FakeContainer()
            self.containers.append(container)
            return container

    return FakeAv()


class FakeModels:
    def __init__(self, directory="model"):
        self.model_directory = Path(directory)

    def directory(self, _model):
        return self.model_directory

    def get_ben2(self, _model_directory, _device):
        from server.models.onnx_ben2 import create_session

        return create_session(self.model_directory, "cpu"), 0.0


    def get_upscale(self, _model_directory, _device):
        return object()


class FakeJobContext:
    def __init__(self, directory, job_type, models=None):
        self.directory = Path(directory)
        self.job_type = job_type
        self.models = models or FakeModels()
        self.status = {}
        self.logs = []

    def resource(self, name):
        if name != "model_manager":
            raise KeyError(name)
        return self.models

    def progress(self, progress, message, **details):
        self.status = {
            "progress": progress,
            "message": message,
            **details,
        }

    def log(self, message, *, level="INFO"):
        self.logs.append((level, message))

    def check_cancelled(self):
        return None