api

def application_launch(event):
    """Event that is executed after Harmony is launched."""
    # fills AYON_HARMONY_JS
    ayon_harmony_path = Path(__file__).parent.parent / "js" / "AyonHarmony.js"
    ayon_harmony_js = ayon_harmony_path.read_text()

    # go through js/creators, loaders and publish folders and load all scripts
    script = ""
    for item in ["creators", "loaders", "publish"]:
        dir_to_scan = Path(__file__).parent.parent / "js" / item
        for child in dir_to_scan.iterdir():
            script += child.read_text()

    # send scripts to Harmony
    harmony.send({"script": ayon_harmony_js})
    harmony.send({"script": script})
    inject_ayon_js()

    # ensure_scene_settings()
    check_inventory()

def check_inventory():
    """Check is scene contains outdated containers.

    If it does it will colorize outdated nodes and optionally display a
    warning dialog.
    """

    outdated_containers = get_outdated_containers()
    if not outdated_containers:
        return

    # Colour nodes.
    outdated_nodes = []
    for container in outdated_containers:
        if container["loader"] == "ImageSequenceLoader":
            outdated_nodes.append(
                harmony.find_node_by_name(container["name"], "READ")
            )
    harmony.send({"function": "AyonHarmony.setColor", "args": outdated_nodes})

    ProcessContext.execute_in_main_thread(prompt_outdated_containers)

def containerise(name,
                 namespace,
                 node,
                 context,
                 loader=None,
                 suffix=None,
                 nodes=None):
    """Imprint node with metadata.

    Containerisation enables a tracking of version, author and origin
    for loaded product representations.

    Arguments:
        name (str): Name of resulting assembly.
        namespace (str): Namespace under which to host container.
        node (str): Node to containerise.
        context (dict): Loaded representation full context information.
        loader (str, optional): Name of loader used to produce this container.
        suffix (str, optional): Suffix of container, defaults to `_CON`.

    Returns:
        container (str): Path of container assembly.
    """
    if not nodes:
        nodes = []

    data = {
        "schema": "openpype:container-2.0",
        "id": AYON_CONTAINER_ID,
        "name": name,
        "namespace": namespace,
        "loader": str(loader),
        "representation": context["representation"]["id"],
        "nodes": nodes
    }

    harmony.imprint(node, data)

    return node

def current_file():
    """Returning None to make Workfiles app look at first file extension."""
    return ProcessContext.workfile_path

def delete_node(node):
    """ Physically delete node from scene. """
    send(
        {
            "function": "AyonHarmonyAPI.deleteNode",
            "args": node
        }
    )

def ensure_scene_settings():
    """Validate if Harmony scene has valid settings."""
    settings = get_current_context_settings()

    invalid_settings = []
    valid_settings = {}
    for key, value in settings.items():
        if value is None:
            invalid_settings.append(key)
        else:
            valid_settings[key] = value

    # Warn about missing attributes.
    if invalid_settings:
        msg = "Missing attributes:"
        for item in invalid_settings:
            msg += f"\n{item}"

        harmony.send(
            {"function": "AyonHarmony.message", "args": msg})

    set_scene_settings(valid_settings)

def export_backdrop_as_template(backdrop, filepath):
    """Export Backdrop as Template (.tpl) file.

    Args:
        backdrop (list): Backdrop to export.
        filepath (str): Path where to save Template.
    """
    harmony.send({
        "function": "AyonHarmony.exportBackdropAsTemplate",
        "args": [
            backdrop,
            os.path.basename(filepath),
            os.path.dirname(filepath)
        ]
    })

def find_backdrop_by_name(name: str) -> Optional[dict]:
    """Find backdrop by its name.

    Args:
        name (str): Name of the backdrop.

    Returns:
        dict: Backdrop.
    """
    backdrops = send(
        {"function": "Backdrop.backdrops", "args": ["Top"]}
    )["result"]
    for backdrop in backdrops:
        if backdrop["title"]["text"] == name:
            return backdrop

    return None

def find_node_by_name(name, node_type):
    """Find node by its name.

    Args:
        name (str): Name of the Node. (without part before '/')
        node_type (str): Type of the Node.
            'READ' - for loaded data with Loaders (background)
            'GROUP' - for loaded data with Loaders (templates)
            'WRITE' - render nodes

    Returns:
        str: FQ Node name.

    """
    nodes = send(
        {"function": "node.getNodes", "args": [[node_type]]}
    )["result"]
    for node in nodes:
        node_name = node.split("/")[-1]
        if name == node_name:
            return node

    return None

def get_all_top_names() -> set:
    """Get all top node and backdrop names in the scene.

    Returns:
        set: Set of top node names.

    """
    nodes = send({"function": "node.subNodes", "args": ["Top"]})["result"]
    backdrops = {
        backdrop["title"]["text"]
        for backdrop in send(
            {"function": "Backdrop.backdrops", "args": ["Top"]}
        )["result"]
    }
    return set(nodes) | backdrops

def get_current_context_settings():
    """Get settings on current task from server.

    Returns:
        dict[str, Any]: Scene data.

    """

    task_entity = get_current_task_entity()
    task_attributes = task_entity["attrib"]

    fps = task_attributes.get("fps")
    frame_start = task_attributes.get("frameStart")
    frame_end = task_attributes.get("frameEnd")
    handle_start = task_attributes.get("handleStart")
    handle_end = task_attributes.get("handleEnd")
    resolution_width = task_attributes.get("resolutionWidth")
    resolution_height = task_attributes.get("resolutionHeight")

    scene_data = {
        "fps": fps,
        "frameStart": frame_start,
        "frameEnd": frame_end,
        "handleStart": handle_start,
        "handleEnd": handle_end,
        "resolutionWidth": resolution_width,
        "resolutionHeight": resolution_height
    }

    return scene_data

def get_palettes_paths() -> set:
    """Get all palettes paths in the scene.

    Returns:
        set: Set of palettes paths.
    """
    return {pal["_path"] for pal in send(
        {"function": "AyonHarmony.getAllPalettesPaths"}
    )["result"]}

def imprint(node_id, data, remove=False):
    """Write `data` to the `node` as json.

    Arguments:
        node_id (str): Path to node or id of object.
        data (dict): Dictionary of key/value pairs.
        remove (bool): Removes the data from the scene.

    Example:
        >>> from ayon_harmony.api import lib
        >>> node = "Top/Display"
        >>> data = {"str": "something", "int": 1, "float": 0.32, "bool": True}
        >>> lib.imprint(layer, data)
    """
    scene_data = get_scene_data()

    if remove and (node_id in scene_data):
        scene_data.pop(node_id, None)
    else:
        if node_id in scene_data:
            scene_data[node_id].update(data)
        else:
            scene_data[node_id] = data

    set_scene_data(scene_data)

def inject_ayon_js():
    """Inject AyonHarmonyAPI.js into Harmony."""
    ayon_harmony_js = Path(__file__).parent.joinpath("js/AyonHarmonyAPI.js")
    script = ayon_harmony_js.read_text()
    # send AyonHarmonyAPI.js to Harmony
    harmony.send({"script": script})

def launch(application_path, *args):
    """Set Harmony for launch.

    Launches Harmony and the server, then starts listening on the main thread
    for callbacks from the server. This is to have Qt applications run in the
    main thread.

    Args:
        application_path (str): Path to Harmony.

    """
    from ayon_core.pipeline import install_host
    from ayon_harmony.api import HarmonyHost

    install_host(HarmonyHost())

    ProcessContext.port = random.randrange(49152, 65535)
    os.environ["AYON_HARMONY_PORT"] = str(ProcessContext.port)
    ProcessContext.application_path = application_path

    # Launch Harmony.
    setup_startup_scripts()
    check_libs()

    if len(args) > 0 and (scene_path := Path(args[-1])).suffix == ".zip":
        launch_zip_file(scene_path)

    open_workfile_app = env_value_to_bool("AYON_HARMONY_WORKFILES_ON_LAUNCH")
    workfile_already_open = ProcessContext.workfile_path
    if is_headless_mode_enabled():
        if not workfile_already_open:
            open_empty_workfile()
    elif open_workfile_app or not workfile_already_open:
        ProcessContext.workfile_tool = host_tools.get_tool_by_name(
            "workfiles"
        )
        host_tools.show_workfiles(save=True)
        ProcessContext.execute_in_main_thread(check_workfiles_tool)

def ls():
    """Yields containers from Harmony scene.

    Clean up scene data from orphaned containers.

    Yields:
        dict: container
    """
    scene_data = harmony.get_scene_data() or dict()
    containers_names = (
        harmony.get_all_top_names() | harmony.get_palettes_paths()
    )
    cleaned_scene_data = False
    for entity_name, entity_data in scene_data.copy().items():
        if not is_container_data(entity_data):
            continue

        # Filter orphaned containers
        if entity_name not in containers_names:
            del scene_data[entity_name]
            cleaned_scene_data = True
            continue

        if not entity_data.get("objectName"):  # backward compatibility
            entity_data["objectName"] = entity_data["name"]
        yield entity_data

    # Update scene data if cleaned
    if cleaned_scene_data:
        harmony.set_scene_data(scene_data)

@contextlib.contextmanager
def maintained_nodes_state(nodes):
    """Maintain nodes states during context."""
    # Collect current state.
    states = send(
        {
            "function": "AyonHarmonyAPI.areEnabled", "args": nodes
        })["result"]

    # Disable all nodes.
    send(
        {
            "function": "AyonHarmonyAPI.disableNodes", "args": nodes
        })

    try:
        yield
    finally:
        send(
            {
                "function": "AyonHarmonyAPI.setState",
                "args": [nodes, states]
            })

def read(node_id):
    """Read object metadata in to a dictionary.

    Args:
        node_id (str): Path to node or id of object.

    Returns:
        dict
    """
    scene_data = get_scene_data()
    if node_id in scene_data:
        return scene_data[node_id]

    return {}

def remove(node_id):
    """
        Remove node data from scene metadata.

        Args:
            node_id (str): full name (eg. 'Top/renderAnimation')
    """
    data = get_scene_data()
    del data[node_id]
    set_scene_data(data)

def rename_node(node_name, new_name):
    """ Rename node name """
    send(
        {
            "function": "AyonHarmony.renameNode",
            "args": [node_name, new_name]
        }
    )

def save_scene(zip_and_move=True):
    """Save the Harmony scene safely.

    The built-in (to AYON) background zip and moving of the Harmony scene
    folder, interferes with server/client communication by sending two
    requests at the same time. This only happens when sending
    "scene.saveAll()". This method prevents this double request and safely
    saves the scene.

    """
    # Need to turn off the background watcher else the communication with
    # the server gets spammed with two requests at the same time.
    scene_path = send(
        {"function": "AyonHarmonyAPI.saveScene"})["result"]

    # # Manually update the remote file.
    if zip_and_move:
        on_file_changed(scene_path, threaded=False)

    # Re-enable the background watcher.
    send({"function": "AyonHarmonyAPI.enableFileWather"})

def save_scene_as(filepath):
    """Save Harmony scene as `filepath`."""
    scene_dir = os.path.dirname(filepath)
    destination = os.path.join(
        os.path.dirname(ProcessContext.workfile_path),
        os.path.splitext(os.path.basename(filepath))[0] + ".zip"
    )

    if os.path.exists(scene_dir):
        try:
            shutil.rmtree(scene_dir)
        except Exception as e:
            log.error(f"Cannot remove {scene_dir}")
            raise Exception(f"Cannot remove {scene_dir}") from e

    send(
        {"function": "scene.saveAs", "args": [scene_dir]}
    )["result"]

    zip_and_move(scene_dir, destination)

    ProcessContext.workfile_path = destination

    send(
        {"function": "AyonHarmonyAPI.addPathToWatcher", "args": filepath}
    )

def select_nodes(nodes):
    """ Selects nodes in Node View """
    _ = send(
        {
            "function": "AyonHarmonyAPI.selectNodes",
            "args": nodes
        }
    )

def send(request):
    """Public method for sending requests to Harmony."""
    return ProcessContext.server.send(request)

def set_scene_data(data):
    """Write scene data to metadata.

    Args:
        data (dict): Data to write.

    """
    # Write scene data.
    send(
        {
            "function": "AyonHarmonyAPI.setSceneData",
            "args": data
        })

def set_scene_settings(settings):
    """Set correct scene settings in Harmony.

    Args:
        settings (dict): Scene settings.

    Returns:
        dict: Dictionary of settings to set.

    """
    harmony.send(
        {"function": "AyonHarmony.setSceneSettings", "args": settings})

def signature(postfix="func") -> str:
    """Return random ECMA6 compatible function name.

    Args:
        postfix (str): name to append to random string.
    Returns:
        str: random function name.

    """
    return "f{}_{}".format(str(uuid4()).replace("-", "_"), postfix)

def unzip_scene_file(filepath: str, headless: bool = False) -> str:
    """Unzip a Harmony scene file and return the path to the .xstage file.

    Args:
        filepath (str): Path to the zip file.
        headless (bool): If True, run without any UI interaction. When a
            local cache exists with the same or newer timestamp, the local
            version will be used automatically. Defaults to False.

    Returns:
        str: Path to the .xstage file.

    Raises:
        Exception: If no .xstage file is found or if the working
            folder cannot be deleted.

    """
    print(f"Localizing {filepath}")

    local_scene_dir_path = Path(get_local_harmony_path(filepath))
    scene_path = local_scene_dir_path.joinpath(
        f"{local_scene_dir_path.name}.xstage"
    )

    unzip = True
    if scene_path.exists():
        # Check remote scene is newer than local.
        if scene_path.stat().st_mtime < Path(filepath).stat().st_mtime:
            # Remote is newer, delete local and unzip
            try:
                shutil.rmtree(local_scene_dir_path)
            except Exception as e:
                log.error(e)
                raise Exception(
                    f"Cannot delete working folder: {local_scene_dir_path}"
                ) from e
            unzip = True
        elif headless:
            # Local is newer or same timestamp - use local cache automatically
            log.info(
                "Headless mode: local cache is newer or same timestamp "
                "as server version. Using local cache."
            )
            unzip = False
        else:
            # Local is newer or same timestamp - ask user
            msg_box = QtWidgets.QMessageBox()
            msg_box.setStyleSheet(style.load_stylesheet())
            msg_box.setIcon(QtWidgets.QMessageBox.Question)
            msg_box.setWindowTitle("Local cache of version exists")
            msg_box.setText(
                "A cached version of this scene exists that is newer or "
                "with the same timestamp as the server version."
            )
            msg_box.setInformativeText(
                "Do you want to use the local file or "
                "re-cache from the server?"
            )
            msg_box.setStandardButtons(
                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No
            )
            msg_box.setDefaultButton(QtWidgets.QMessageBox.Yes)

            msg_box.button(QtWidgets.QMessageBox.Yes).setText("Use Local")
            msg_box.button(QtWidgets.QMessageBox.No).setText("From Server")

            msg_box.setModal(True)

            result = msg_box.exec_()

            if result == QtWidgets.QMessageBox.No:
                try:
                    shutil.rmtree(local_scene_dir_path)
                except Exception as e:
                    log.error(e)
                    raise Exception(
                       f"Cannot delete working folder '{local_scene_dir_path}'"
                    ) from e
                unzip = True
            else:
                unzip = False

    if unzip:
        filepath = localize_file(filepath)
        with _ZipFile(filepath, "r") as zip_ref:
            names = zip_ref.namelist()
            main_name = next(
                Path(name).stem
                for name in names
                if name.endswith(".xstage")
            )

            # Detect if the archive is wrapped in a single root directory
            # named after `main_name`. When it is, we extract into the
            # parent of the local scene dir so the (renamed) root dir
            # becomes the local scene dir itself.
            has_root_dir = all(
                name == f"{main_name}/"
                or name.startswith(f"{main_name}/")
                for name in names
            )
            extract_root = (
                local_scene_dir_path.parent
                if has_root_dir
                else local_scene_dir_path
            )
            new_name = local_scene_dir_path.name
            root_prefix = f"{main_name}/"

            def _rename_top_level_file(name):
                if "/" not in name and Path(name).stem == main_name:
                    return f"{new_name}{Path(name).suffix}"
                return name

            for zip_info in zip_ref.infolist():
                if has_root_dir:
                    # Root-dir archives are handled by applying the same
                    # top-level file rename one level deeper and then
                    # reattaching the renamed root directory prefix.
                    relative_name = zip_info.filename[len(root_prefix):]
                    relative_name = _rename_top_level_file(relative_name)
                    zip_info.filename = f"{new_name}/{relative_name}"
                else:
                    zip_info.filename = _rename_top_level_file(
                        zip_info.filename
                    )

                zip_ref.extract(zip_info, extract_root)
        scene_path = next(local_scene_dir_path.glob("*.xstage"), None)

    if not scene_path:
        raise Exception("No xstage file was found.")

    return scene_path.as_posix()