pipeline

def copy_ayon_data(filepath):
    """Copy any ayon-related data(
        such as instances, create-context, cotnainers)
        from the previous workfile to the new one
        when incrementing and saving workfile.

    Args:
        filepath (str): the workfile path to be saved
    """
    filename = os.path.splitext(os.path.basename(filepath))[0].strip()
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    for name in [ZBRUSH_METADATA_CREATE_CONTEXT,
                 ZBRUSH_SECTION_NAME_INSTANCES,
                 ZBRUSH_SECTION_NAME_CONTAINERS]:
        src_json_dir = os.path.join(
            work_dir, ".zbrush_metadata", current_file, name).replace(
                "\\", "/"
            )
        if not os.path.exists(src_json_dir):
            continue
        dst_json_dir = os.path.join(
            work_dir, ".zbrush_metadata", filename, name).replace(
                "\\", "/"
            )
        os.makedirs(dst_json_dir, exist_ok=True)
        all_fname_list = [jfile for jfile in os.listdir(src_json_dir)
                        if jfile.endswith("json")]
        if all_fname_list:
            for fname in all_fname_list:
                src_json = f"{src_json_dir}/{fname}"
                dst_json = f"{dst_json_dir}/{fname}"
                shutil.copy(src_json, dst_json)

def get_containers():
    """Function to get the container data

    Returns:
        list: list of container data
    """
    output = get_load_workfile_metadata(ZBRUSH_SECTION_NAME_CONTAINERS)
    if output:
        for item in output:
            if "objectName" not in item and "name" in item:
                members = item["name"]
                if isinstance(members, list):
                    members = "|".join([str(member) for member in members])
                item["objectName"] = members

    return output

def get_current_workfile_context():
    """Function to get the current context data from the related
    json file in .zbrush_metadata/context folder

    The current context data includes thing like project name,
    folder path and task name.

    Returns:
        list: list of context data
    """
    return get_load_context_metadata()

def get_instance_workfile_metadata():
    """Get instance data from the related metadata json("instances.json")
    which stores in .zbrush_metadata/{workfile}/instances folder
    in the project work directory.

    Instance data includes the info like the workfile instance
    and any instances created by the users for publishing.

    Returns:
        dict: instance data
    """
    file_content = []
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, ZBRUSH_SECTION_NAME_INSTANCES).replace(
            "\\", "/"
        )
    if not os.path.exists(json_dir) or not os.listdir(json_dir):
        return file_content
    for file in os.listdir(json_dir):
        with open (f"{json_dir}/{file}", "r") as data:
            file_content = json.load(data)

    return file_content

def get_load_context_metadata():
    """Get the context data from the related json file
    ("context.json") which stores in .zbrush_metadata/context
    folder in the project work directory.

    The context data includes the project name, folder path and
    task name.

    Returns:
        list: context data
    """
    file_content = {}
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata", ZBRUSH_SECTION_NAME_CONTEXT).replace(
            "\\", "/"
        )
    if not os.path.exists(json_dir):
        return file_content
    file_list = os.listdir(json_dir)
    if not file_list:
        return file_content
    for file in file_list:
        with open (f"{json_dir}/{file}", "r") as data:
            content = ast.literal_eval(str(data.read().strip()))
            file_content.update(content)
            data.close()
    return file_content

def get_load_workfile_metadata(metadata_key):
    """Get to load the workfile json metadata(such as
    creator's context data and container data) which stores in
    zbrush_metadata/{workfile}/{metadata_key} folder in the project
    work directory.
    It mainly supports to the metadata_key below:
    ZBRUSH_METADATA_CREATE_CONTEXT: loading create_context.json where
        stores the data with publish_attributes(e.g. whether the
        optional validator is enabled.)
    ZBRUSH_SECTION_NAME_CONTAINERS: loading {subset_name}.json where
        includes all the loaded asset data to the zbrush scene.

    Args:
        metadata_key (str): name of the metadata key

    Returns:
        list: list of metadata(create-context data or container data)
    """
    file_content = []
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, metadata_key).replace(
            "\\", "/"
        )
    if not os.path.exists(json_dir):
        return file_content
    file_list = os.listdir(json_dir)
    if not file_list:
        return file_content
    for file in file_list:
        with open (f"{json_dir}/{file}", "r") as data:
            content = json.load(data)
            file_content.extend(content)
            data.close()
    return file_content

def imprint(container, representation_id):
    """Function to update the container data from
    the related json file in .zbrushmetadata/{workfile}/container
    when updating or switching asset(s)

    Args:
        container (str): container
        representation_id (str): representation id
    """
    old_container_data = []
    data = {}
    name = container["objectName"]
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, ZBRUSH_SECTION_NAME_CONTAINERS).replace(
            "\\", "/"
        )
    js_fname = next((jfile for jfile in os.listdir(json_dir)
                     if jfile.endswith(f"{name}.json")), None)
    if js_fname:
        with open(f"{json_dir}/{js_fname}", "r") as file:
            old_container_data = json.load(file)
            print(f"data: {type(old_container_data)}")
            file.close()

        open(f"{json_dir}/{js_fname}", 'w').close()
        for item in old_container_data:
            item["representation"] = representation_id
            data.update(item)
        with open(f"{json_dir}/{js_fname}", "w") as file:
            new_container_data = json.dumps([data])
            file.write(new_container_data)
            file.close()

def remove_container_data(name):
    """Function to remove the specific container data from
    {subset_name}.json in .zbrush_metadata/{workfile}/containers folder

    Args:
        name (str): object name stored in the container
    """
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, ZBRUSH_SECTION_NAME_CONTAINERS).replace(
            "\\", "/"
        )
    all_fname_list = os.listdir(json_dir)
    json_file = next((jfile for jfile in all_fname_list
                               if jfile == f"{name}.json"), None)
    if json_file:
        os.remove(f"{json_dir}/{json_file}")

def remove_tmp_data():
    """Remove all temporary data which is created by AYON without
    saving changes when launching Zbrush without enabling `skip
    opening last workfile`

    """
    work_dir = get_workdir()
    for name in [ZBRUSH_METADATA_CREATE_CONTEXT,
                 ZBRUSH_SECTION_NAME_INSTANCES,
                 ZBRUSH_SECTION_NAME_CONTAINERS]:
        json_dir = os.path.join(
            work_dir, ".zbrush_metadata", name).replace(
                "\\", "/"
            )
        if not os.path.exists(json_dir):
            continue
        all_fname_list = [jfile for jfile in os.listdir(json_dir)
                          if jfile.endswith("json")]
        for fname in all_fname_list:
            os.remove(f"{json_dir}/{fname}")

def save_current_workfile_context(context):
    """Save current workfile context data to `.zbrush_metadata/{workfile}/key`

    This persists the current in-memory context to be set for a specific
    workfile on disk. Usually used on save to persist the local sessions'
    workfile context on save.

    The context data includes things like the project name, folder path,
    etc.

    Args:
        context (dict): context data

    """
    return write_context_metadata(ZBRUSH_SECTION_NAME_CONTEXT, context)

def set_current_file(filepath=None):
    """Function to store current workfile path

    Args:
        filepath (str, optional): current workfile path. Defaults to None.
    """
    work_dir = get_workdir()
    txt_dir = os.path.join(
        work_dir, ".zbrush_metadata").replace(
            "\\", "/"
    )
    os.makedirs(txt_dir, exist_ok=True)
    txt_file = f"{txt_dir}/current_file.txt"
    if filepath is None:
        with open(txt_file, "w"):
            pass
        return filepath
    filepath_check = tmp_current_file_check()
    if filepath_check.endswith("zpr"):
        filepath = os.path.join(
            os.path.dirname(filepath), filepath_check).replace("\\", "/")
    with open (txt_file, "w") as current_file:
        current_file.write(filepath)
        current_file.close()

def tmp_current_file_check():
    """Function to find the latest .zpr file used
    by the user in Zbrush.

    Returns:
        file_content (str): the filepath in .zpr format.
            If the filepath does not end with '.zpr' format,
            it returns None.
    """
    output_file = tempfile.NamedTemporaryFile(
        mode="w", prefix="a_zb_cfc", suffix=".txt", delete=False
    )
    output_file.close()
    output_filepath = output_file.name.replace("\\", "/")
    context_data_zscript = ("""
[IFreeze,
	[MemCreate, currentfile, 1000, 0]
    [VarSet, currentfile, [FileNameExtract, [FileNameGetLastUsed], 2+4]]
	[MemWriteString, currentfile, #filename, 0]
	[MemSaveToFile, currentfile, "{output_filepath}", 0]
	[MemDelete, currentfile]
]
""").format(output_filepath=output_filepath)
    execute_zscript(context_data_zscript)
    with open(output_filepath) as data:
        file_content = str(data.read().strip()).rstrip('\x00')
    os.remove(output_filepath)
    return file_content

def write_context_metadata(metadata_key, context):
    """Write context data into the related json
    which stores in .zbrush_metadata/key folder
    in the project work directory.

    The context data includes the project name, folder path
    and task name.

    Args:
        metadata_key (str): metadata key
        context (dict): context data
    """
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata", metadata_key).replace(
            "\\", "/"
        )
    os.makedirs(json_dir, exist_ok=True)
    json_file = f"{json_dir}/{metadata_key}.json"
    if os.path.exists(json_file):
        with open (json_file, "r") as file:
            value = json.load(file)
            if value == context:
                return
    with open (json_file, "w") as file:
        value = json.dumps(context)
        file.write(value)
        file.close()

def write_load_metadata(data):
    """Write/Edit the container data into the related json file("{subset_name}.json")
    which stores in .zbrush_metadata/{workfile}/containers folder.
    This persists the current in-memory containers data
    to be set for updating and switching assets in scene inventory.

    Args:
        metadata_key (str): metadata key for container
        data (list): list of container data
    """
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    name = next((d["name"] for d in data), None)
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, ZBRUSH_SECTION_NAME_CONTAINERS).replace(
            "\\", "/"
        )
    os.makedirs(json_dir, exist_ok=True)
    json_file = f"{json_dir}/{name}.json"
    if os.path.exists(json_file):
        with open(json_file, "w"):
            pass

    with open(json_file, "w") as file:
        value = json.dumps(data)
        file.write(value)
        file.close()

def write_workfile_metadata(metadata_key, data=None):
    """Function to write workfile metadata(such as creator's context data
    and instance data) in .zbrushmetadata/{workfile}/{metadata_key} folder
    This persists the current in-memory instance/creator's context data
    to be set for a specific workfile on disk. Usually used on save to
    persist updating instance data and context data used in publisher.

    Args:
        metadata_key (str): metadata key
        data (list, optional): metadata. Defaults to None.
    """
    if data is None:
        data = []
    current_file = registered_host().get_current_workfile()
    if current_file:
        current_file = os.path.splitext(
            os.path.basename(current_file))[0].strip()
    work_dir = get_workdir()
    json_dir = os.path.join(
        work_dir, ".zbrush_metadata",
        current_file, metadata_key).replace(
            "\\", "/"
        )
    os.makedirs(json_dir, exist_ok=True)
    with open (f"{json_dir}/{metadata_key}.json", "w") as file:
        value = json.dumps(data)
        file.write(value)
        file.close()