NeoGF/gcmtool/gcmtool.py

#!/usr/bin/env python3
from configparser import ConfigParser
import logging
from pathlib import Path
import re


__version__ = "0.2.1"
__author__ = "rigodron, algoflash, GGLinnk"
__license__ = "MIT"
__status__ = "developpement"


# raised when the boot.bin DVD magic number is invalid
class InvalidDVDMagicError(Exception): pass
# raised when unpack folder already exist to avoid erasing already existing files
class InvalidUnpackFolderError(Exception): pass
# raised when pack iso already exist to avoid erasing already existing file
class InvalidPackIsoError(Exception): pass
# raised during pack when fst.bin size doesn't match the boot.bin value 
class InvalidFSTSizeError(Exception): pass
# raised during pack when boot.dol size overflow on first file or on FST
class DolSizeOverflowError(Exception): pass
# raised during pack when fst.bin size overflow on first file or on dol
class FstSizeOverflowError(Exception): pass
# raised during pack when FST folder entry has an invalid nextdir id value; this happen when file and folder has been added/removed
class InvalidRootFileFolderCountError(Exception): pass
# raised during pack when FST file entry has a different value than the file being packed; this happen when a file has been edited changing it's size
class InvalidFSTFileSizeError(Exception): pass
# raised during pack when FST dir name is not found in the root folder; this happen when a dir is renamed or removed
class FSTDirNotFoundError(Exception): pass
# raised during pack when FST file name is not found in the root folder; this happen when a file is renamed or removed
class FSTFileNotFoundError(Exception): pass
# raised when using an invalid align
class BadAlignError(Exception): pass
# raised when a system conf entry has an invalid format
class InvalidConfValueError(Exception): pass
# raised when apploader overflow on dol or fst
class ApploaderOverflowError(Exception): pass


def align_top(offset:int, align:int):
    """
    Give the upper rounded offset aligned using the align value.
    input: offset = int
    input: align = int
    return offset = int
    """
    if offset % align == 0: return offset
    return offset + align - (offset % align)


class Fst:
    "Pack FST type enum values."
    TYPE_FILE = 0
    TYPE_DIR = 1


class Node:
    """
    Interface Node used to be herited by File and Folder classes.
    It groups common properties and allow an FST rebuid:
        FST use a base_name block and name offsets relative to it for all
        entries: Files or Folders. So we handle name in this interface.
        name offset will be set during the FstTree.__prepare() after all
        of the three elements are added.
        Also every File and Folder get an ID. This ID is important when
        rebuilding the FST with folders (next dir, parent dir) ...
    Constructor: name = str (file or folder)
    """
    __id = None
    __name = None
    __name_offset = None
    def __init__(self, name:str):
        self.__name = name
    def id(self):             return self.__id
    def name(self):           return self.__name
    def name_offset(self):    return self.__name_offset
    def set_id(self, id:int): self.__id = id
    def set_name_offset(self, name_offset:int): self.__name_offset = name_offset


class File(Node):
    """
    Use a global class attribute TYPE_FILE and store necessary
    informations for formating the FST 12 bytes entry with the
    format "type/name_offset/gcm_offset/size"
    Constructor:
    * name = str
    * size = int
    """
    __type = Fst.TYPE_FILE
    __size = None
    __offset = None
    def __init__(self, name:str, size:int):
        super().__init__(name)
        self.__size = size
    def __str__(self):
        return f"{self.id()};{self.name()};{self.size()};{self.offset()};{self.name_offset()}"
    def type(self):                   return self.__type
    def size(self):                   return self.__size
    def offset(self):                 return self.__offset
    def set_offset(self, offset:int): self.__offset = offset 
    def format(self):
        return self.type().to_bytes(1, "big") + self.name_offset().to_bytes(3, "big") + self.offset().to_bytes(4, "big") + self.size().to_bytes(4, "big")


class Folder(Node):
    """
    Use a global class attribute TYPE_DIR and store necessary
    informations for formating the FST 12 bytes entry with the
    format "type/name_offset/parent_id/next_id". This class is 
    intended to hold the tree with multiple childs and one parent
    only. The next dir is the total number of childs + 1
    Constructor:
    * name = str
    * parent = Node
    """
    __type = Fst.TYPE_DIR
    __parent = None
    __next_dir = None
    __childs = None
    def __init__(self, name:str, parent:Node):
        super().__init__(name)
        self.__parent = parent
        self.__childs = []
    def __str__(self):
        return f"{self.id()};{self.name()};{self.next_dir()};{self.name_offset()}"
    def type(self):                   return self.__type
    def parent(self):                 return self.__parent
    def next_dir(self):               return self.__next_dir
    def childs(self):                 return self.__childs
    def set_next_dir(self, next_dir): self.__next_dir = next_dir
    def add_child(self, node:Node):
        "Search child by name an return existing if found or new if not existing"
        for child in self.__childs:
            if node.name() == child.name():
                return child
        self.__childs.append(node)
        return node
    def format(self):
        return self.type().to_bytes(1, "big") + self.name_offset().to_bytes(3, "big") + self.parent().id().to_bytes(4, "big") + self.next_dir().to_bytes(4, "big")


class FstTree(Fst):
    """
    FstTree is responsible for creating and formating the FST and name_block.
    We store a root Node that is a special Folder.
    Constructor:
    * root_path = Path (the part with folder that are out of the tree)
    * fst_offset = int (to know where is the current min offset before 
        adding the fst and name_block length)
        has to be aligned
    * align = int (It could change in some GCM)
    """
    # When we walk recursivly in a path we don't wan't to add theirs out parents so it allow to stop at the folder we choose as root
    __root_path_length = None
    __root_node = None
    # We start at root-node with id=0
    __current_id = 0
    # We will align this offset to the next available place after new packed file
    __current_file_offset = None
    __align = None
    __fst_block = None
    __name_block = None
    # Used to find min file_offset when fst is at the end of the iso beginning (otherweise we can't know the first available offset)
    __nameblock_length = None
    __user_position = None
    __user_length = None
    # FST high tell if fst is after dol
    __is_fst_last = None
    def __init__(self, root_path:Path, offset:int, is_fst_last:bool, align:int = 4):
        # as said before we don't want to add parents folder that don't are used in the folder we are packing.
        self.__root_path_length = len(root_path.parts)
        self.__root_node = Folder(root_path.name, None)
        self.__align = align
        self.__name_block = b""
        self.__fst_block = b""
        self.__nameblock_length = 0
        self.__current_file_offset = offset
        self.__is_fst_last = is_fst_last
    def __str__(self):
        return self.__to_str(self.__root_node)
    def __to_str(self, node:Node, depth=0):
        """
        Recursive Tree str buffer for debug.
        input: Node (to print childs)
        return tree = str
        """
        result = (depth * "    ") + str(node) +"\n"
        if node.type() == FstTree.TYPE_DIR:
            for child in node.childs():
                result += self.__to_str(child, depth+1)
        return result
    def __get_fst_length(self):
        """
        Needed to know where we can begin to write files.
        return fst_length = int
        """
        self.__generate_nameblock_length()
        return align_top(self.__count_childs(self.__root_node)*12 + 12 + self.__nameblock_length, self.__align)
    def __generate_nameblock_length(self, node:Node = None):
        """
        Recursive walk into the tree to get total name_block length.
        input: None (then it will use node:Node to recurse)
        """
        if node is None:
            node = self.__root_node
        else:
            self.__nameblock_length += len(node.name()) + 1
        if node.type() == FstTree.TYPE_DIR:
            for child in node.childs():
                self.__generate_nameblock_length(child)
    def __prepare(self, node:Node = None):
        """
        Populate recursivly every Nodes with required informations for formating and generate the name_block and fst_block.
        input: None (then it will use node:Node to recurse)
        """
        name_offset = 0
        # For root Node we build the nameblock with null trailing byte
        # For others we build the name_block and update the name_offset
        if node is None:
            node = self.__root_node
        else:
            name_offset = len(self.__name_block)
            self.__name_block += node.name().encode("utf-8")+b"\x00"
        # We set the name_offset, the id, we increment for next walked node
        node.set_name_offset(name_offset)
        node.set_id(self.__current_id)
        self.__current_id += 1
        
        # If it's a directory we have to count childs to set nextdir
        # If it's a file we have to set the offset and add length aligned to it for finding next available offset
        # At the end we add to the fst_block our formated Node
        if node.type() == FstTree.TYPE_DIR:
            node.set_next_dir(self.__current_id + self.__count_childs(node))
            if node == self.__root_node:
                self.__fst_block = b"\x01\x00\x00\x00\x00\x00\x00\x00" + node.next_dir().to_bytes(4, "big")
            else:
                self.__fst_block += node.format()
            for child in node.childs():
                self.__prepare(child)
        else:
            node.set_offset(self.__current_file_offset)
            self.__fst_block += node.format()
            self.__current_file_offset = align_top(self.__current_file_offset + node.size(), self.__align)
    def __count_childs(self, node:Folder):
        """
        Recursivly count total childs of a Node. It is usefull for getting next_dir id.
        input: node = Folder
        return child_count = int
        """
        count = 0
        for child in node.childs():
            if child.type() == FstTree.TYPE_DIR:
                count += self.__count_childs(child)
        return count + len(node.childs())
    def add_node_by_path(self, node_path:Path):
        """
        Add a path with each folder as Folder class and the File as a leaf.
        We take care to set parent and childs for folder and retrieve necessary
        informations from the node_path input:
        * name
        * size
        * parent id & parent->child
        input: path = Path (folder / file)
        """
        parent = self.__root_node
        node = None
        for i in range(self.__root_path_length, len(node_path.parts)-1):
            node = Folder(node_path.parts[i], parent)
            parent = parent.add_child(node)
        if node_path.is_file():
            node = File(node_path.name, node_path.stat().st_size)
        else:
            node = Folder(node_path.name, parent)
        parent.add_child(node)
    def generate_fst(self):
        """
        Generate the FST.
        The hard part Here is that we have to know the result before
        knowing where we can begin to add files.
        """
        if self.__is_fst_last:
            self.__current_file_offset += self.__get_fst_length() # aligned + aligned = aligned
        self.__user_position = self.__current_file_offset
        self.__prepare()
        self.__user_length = self.__current_file_offset - self.__user_position
        return self.__fst_block + self.__name_block
    def user_position(self): return self.__user_position
    def user_length(self):   return self.__user_length


class BootBin:
    """
    BootBin describe the Disc Header "boot.bin" file at the beginning of 
    the GCM/iso. It groups all operations related to the boot.bin system 
    file extracted in sys/boot.bin. Using this class avoid errors on offsets
    and makes it easier to get or set values.
    Constructor:
    * datas = bytes or bytearray if edit of the boot.bin is needed.
    """
    LEN = 0x440
    DOLOFFSET_OFFSET = 0x420
    FSTOFFSET_OFFSET = 0x424
    FSTLEN_OFFSET = 0x428
    FSTMAXLEN_OFFSET = 0x42c
    __data = None
    def __init__(self, data:bytes): self.__data = data
    def data(self):               return self.__data
    def make_mut(self):           self.__data = bytearray(self.__data)
    def game_code(self):          return self.__data[:4].decode("ascii")
    def maker_code(self):         return self.__data[4:6].decode("ascii")
    def disc_number(self):        return int.from_bytes(self.__data[6:7], 'big')
    def game_version(self):       return int.from_bytes(self.__data[7:8], 'big')
    def audio_streaming(self):    return int.from_bytes(self.__data[8:9], 'big')
    def stream_buffer_size(self): return int.from_bytes(self.__data[9:0xa], 'big')
    def dvd_magic(self):          return self.__data[0x1c:0x20]
    def game_name(self):          return self.__data[0x20:0x60].split(b"\x00")[0].decode("utf-8")
    def dol_offset(self):         return int.from_bytes(self.__data[BootBin.DOLOFFSET_OFFSET:BootBin.DOLOFFSET_OFFSET+4],"big")
    def fst_offset(self):         return int.from_bytes(self.__data[BootBin.FSTOFFSET_OFFSET:BootBin.FSTOFFSET_OFFSET+4],"big")
    def fst_len(self):            return int.from_bytes(self.__data[BootBin.FSTLEN_OFFSET:BootBin.FSTLEN_OFFSET+4],"big")
    def fst_max_len(self):        return int.from_bytes(self.__data[BootBin.FSTMAXLEN_OFFSET:BootBin.FSTMAXLEN_OFFSET+4],"big")
    def user_position(self):      return int.from_bytes(self.__data[0x434:0x438],"big")
    def user_length(self):        return int.from_bytes(self.__data[0x438:0x43c],"big")
    def set_game_code(self, game_code:str):
        self.__data[:4] = bytes(game_code, "ascii")
    def set_maker_code(self, maker_code:str):
        self.__data[4:6] = bytes(maker_code, "ascii")
    def set_disc_number(self, disc_number:int):
        self.__data[6:7] = disc_number.to_bytes(1, "big")
    def set_game_version(self, game_version:int):
        self.__data[7:8] = game_version.to_bytes(1, "big")
    def set_audio_streaming(self, audio_streaming:int):
        self.__data[8:9] = audio_streaming.to_bytes(1, "big")
    def set_stream_buffer_size(self, stream_buffer_size:int):
        self.__data[9:0xa] = stream_buffer_size.to_bytes(1, "big")
    def set_dvd_magic(self, dvd_magic:int):
        self.__data[0x1c:0x20] = dvd_magic.to_bytes(4, "big")
    def set_game_name(self, game_name:int):
        self.__data[0x20:0x60] = bytes(game_name, "utf-8").ljust(0x40, b"\x00")
    def set_dol_offset(self, offset:int):
        self.__data[BootBin.DOLOFFSET_OFFSET:BootBin.DOLOFFSET_OFFSET+4] = offset.to_bytes(4, "big")
    def set_fst_offset(self, offset:int):
        self.__data[BootBin.FSTOFFSET_OFFSET:BootBin.FSTOFFSET_OFFSET+4] = offset.to_bytes(4, "big")
    def set_fst_len(self, length:int):
        self.__data[BootBin.FSTLEN_OFFSET:BootBin.FSTLEN_OFFSET+4] = length.to_bytes(4, "big")
    def set_fst_max_len(self, length:int):
        self.__data[BootBin.FSTMAXLEN_OFFSET:BootBin.FSTMAXLEN_OFFSET+4] = length.to_bytes(4, "big")
    def set_user_position(self, user_position:int):
        self.__data[0x434:0x438] = user_position.to_bytes(4, "big")
    def set_user_length(self, user_length:int):
        self.__data[0x438:0x43c] = user_length.to_bytes(4, "big")


class Bi2Bin:
    """
    Bi2Bin describe the Disc Header Information "bi2.bin" file at the 
    beginning of the GCM/iso after boot.bin. It groups all operations
    related to the bi2.bin system file extracted in sys/bi2.bin. Using 
    this class avoid errors on offsets and makes it easier to get or set 
    values.
    Constructor:
    * datas = bytes or bytearray if edit of the bi2.bin is needed.
    """
    LEN = 0x2000
    __data = None
    def __init__(self, data:bytes): self.__data = data
    def data(self):                 return self.__data
    def make_mut(self):             self.__data = bytearray(self.__data)
    def debug_monitor_size(self):     return int.from_bytes(self.__data[:4], "big")
    def simulated_memory_size(self):  return int.from_bytes(self.__data[4:8], "big")
    def argument_offset(self):        return int.from_bytes(self.__data[8:12], "big")
    def debug_flag(self):             return int.from_bytes(self.__data[12:16], "big")
    def track_location(self):         return int.from_bytes(self.__data[16:20], "big")
    def track_size(self):             return int.from_bytes(self.__data[20:24], "big")
    def country_code(self):           return int.from_bytes(self.__data[24:28], "big")
    def total_disc(self):             return int.from_bytes(self.__data[28:32], "big")
    def long_file_name_support(self): return int.from_bytes(self.__data[32:36], "big")
    def dol_limit(self):              return int.from_bytes(self.__data[40:44], "big")
    def set_debug_monitor_size(self, debug_monitor_size:int):
        self.__data[:4] = debug_monitor_size.to_bytes(4, "big")
    def set_simulated_memory_size(self, simulated_memory_size:int):
        self.__data[4:8] = simulated_memory_size.to_bytes(4, "big")
    def set_argument_offset(self, argument_offset:int):
        self.__data[8:12] = argument_offset.to_bytes(4, "big")
    def set_debug_flag(self, debug_flag:int):
        self.__data[12:16] = debug_flag.to_bytes(4, "big")
    def set_track_location(self, track_location:int):
        self.__data[16:20] = track_location.to_bytes(4, "big")
    def set_track_size(self, track_size:int):
        self.__data[20:24] = track_size.to_bytes(4, "big")
    def set_country_code(self, country_code:int):
        self.__data[24:28] = country_code.to_bytes(4, "big")
    def set_total_disc(self, total_disc:int):
        self.__data[28:32] = total_disc.to_bytes(4, "big")
    def set_long_file_name_support(self, long_file_name_support:int):
        self.__data[32:36] = long_file_name_support.to_bytes(4, "big")
    def set_dol_limit(self, dol_limit:int):
        self.__data[40:44] = dol_limit.to_bytes(4, "big")
        

class ApploaderImg:
    __data = None
    def __init__(self, data:bytes): self.__data = data
    def data(self):         return self.__data
    def len(self):          return len(self.__data)
    def make_mut(self):     self.__data = bytearray(self.__data)
    def version(self):      return self.__data[:0x10].split(b"\x00")[0].decode("ascii")
    def entry_point(self):  return int.from_bytes(self.__data[0x10:0x14], "big")
    def size(self):         return int.from_bytes(self.__data[0x14:0x18], "big")
    def trailer_size(self): return int.from_bytes(self.__data[0x18:0x1c], "big")
    def set_version(self, version:int):           self.__data[:0x10]     = bytes(version, "ascii").ljust(0x10, b"\x00")
    def set_entry_point(self, entry_point:int):   self.__data[0x10:0x14] = entry_point.to_bytes(4, "big")
    def set_size(self, size:int):                 self.__data[0x14:0x18] = size.to_bytes(4, "big")
    def set_trailer_size(self, trailer_size:int): self.__data[0x18:0x1c] = trailer_size.to_bytes(4, "big")


class Dol:
    "Dol is used to find the dol size and group data adding meaning to hex values and allowing to get it's size."
    HEADER_LEN = 0x100
    HEADER_SECTIONLENTABLE_OFFSET = 0x90
    def get_dol_len(self, dolheader_data:bytes):
        """
        Get total length using the sum of the 18 sections length and dol header length.
        * input: dolheader_data = bytes
        * return dol_len = int
        """
        dol_len = Dol.HEADER_LEN
        for i in range(18):
            dol_len += int.from_bytes(dolheader_data[Dol.HEADER_SECTIONLENTABLE_OFFSET+i*4:Dol.HEADER_SECTIONLENTABLE_OFFSET+(i+1)*4], "big")
        return dol_len


class Gcm:
    """
    Gcm handle all operations needed by the command parser.
    File format informations: https://sudonull.com/post/68549-Gamecube-file-system-device
    """
    APPLOADER_HEADER_LEN = 0x20
    APPLOADER_OFFSET = 0x2440
    APPLOADERLEN_OFFSET = 0x2454
    DVD_MAGIC = b"\xC2\x33\x9F\x3D"
    __bootbin = None # Disc header
    __bi2bin = None  # Disc header Information
    __apploaderimg = None
    __hex_pattern = re.compile("^0x[0-9a-fA-F]+$")
    def __save_conf(self, sys_path:Path):
        "Read boot.bin and bi2.bin and save theirs conf in sys/system.conf."

        config = ConfigParser(allow_no_value=True) # allow_no_value to allow adding comments
        config.optionxform = str # makes options case sensitive
        config.add_section("Default")
        config.set("Default", "# Documentation available here: https://github.com/Virtual-World-RE/NeoGF/blob/main/gcmtool/README.md#syssytemconf")
        config.set("Default", "boot.bin_section", "disabled")
        config.set("Default", "bi2.bin_section", "disabled")
        config.set("Default", "apploader.img_section", "disabled")

        config.add_section("boot.bin")
        config.set("boot.bin", "GameCode",         self.__bootbin.game_code()) # 4 bytes ASCII
        config.set("boot.bin", "MakerCode",        self.__bootbin.maker_code()) # 2 bytes ASCII
        config.set("boot.bin", "DiscNumber",       str(self.__bootbin.disc_number())) # 0-98
        config.set("boot.bin", "GameVersion",      str(self.__bootbin.game_version())) # 0-99
        config.set("boot.bin", "AudioStreaming",   str(self.__bootbin.audio_streaming())) # 0 or 1 flag
        config.set("boot.bin", "StreamBufferSize", str(self.__bootbin.stream_buffer_size())) # 0-15
        config.set("boot.bin", "DVDMagic",         "0x" + self.__bootbin.dvd_magic().hex())
        config.set("boot.bin", "GameName",         self.__bootbin.game_name()) # 64 bytes
        config.set("boot.bin", "DolOffset",        f"auto")
        config.set("boot.bin", "FstOffset",        f"auto")
        config.set("boot.bin", "FstLen",           f"auto")
        config.set("boot.bin", "FstMaxLen",        f"auto")
        config.set("boot.bin", "UserPosition",     f"auto")
        config.set("boot.bin", "UserLength",       f"auto")
        

        config.add_section("bi2.bin")
        config.set("bi2.bin", "DebugMonitorSize",    f"0x{self.__bi2bin.debug_monitor_size():x}")
        config.set("bi2.bin", "SimulatedMemorySize", f"0x{self.__bi2bin.simulated_memory_size():x}")
        config.set("bi2.bin", "ArgumentOffset",      f"0x{self.__bi2bin.argument_offset():x}")
        config.set("bi2.bin", "DebugFlag",           str(self.__bi2bin.debug_flag()))
        config.set("bi2.bin", "TrackLocation",       f"0x{self.__bi2bin.track_location():x}")
        config.set("bi2.bin", "TrackSize",           f"0x{self.__bi2bin.track_size():x}")
        config.set("bi2.bin", "CountryCode",         str(self.__bi2bin.country_code())) # 0, 1, 2, 4
        config.set("bi2.bin", "TotalDisc",           str(self.__bi2bin.total_disc())) # 1-99
        config.set("bi2.bin", "LongFileNameSupport", str(self.__bi2bin.long_file_name_support())) # 0, 1
        config.set("bi2.bin", "DolLimit",            f"0x{self.__bi2bin.dol_limit():x}")

        config.add_section("apploader.img")
        config.set("apploader.img", "Version",     self.__apploaderimg.version())
        config.set("apploader.img", "EntryPoint",  f"0x{self.__apploaderimg.entry_point():x}")
        config.set("apploader.img", "Size",        f"0x{self.__apploaderimg.size():x}")
        config.set("apploader.img", "TrailerSize", f"0x{self.__apploaderimg.trailer_size():x}")

        with (sys_path / "system.conf").open("w") as conf_file:
            config.write(conf_file)
        logging.info("sys/sytem.conf saved.")
    def __load_conf(self, sys_path:Path, get_conf_values:bool = False):
        "Patch boot.bin, bi2.bin and apploader.img with the conf in sys/system.conf if Default section status is enabled."
        config = ConfigParser(allow_no_value=True) # allow_no_value to allow adding comments
        config.optionxform = str # makes options case sensitive
        config.read(sys_path / "system.conf")

        if config["Default"]["boot.bin_section"].lower() not in ["enabled", "disabled"]:
            raise InvalidConfValueError("Error - Invalid [Default][boot.bin_section]: must be enabled or disabled.")
        if config["Default"]["bi2.bin_section"].lower() not in ["enabled", "disabled"]:
            raise InvalidConfValueError("Error - Invalid [Default][bi2.bin_section]: must be enabled or disabled.")
        if config["Default"]["apploader.img_section"].lower() not in ["enabled", "disabled"]:
            raise InvalidConfValueError("Error - Invalid [Default][apploader.img_section]: must be enabled or disabled.")

        def check_numeric_format(config:ConfigParser, conf_list:list):
            for conf in conf_list:
                if not config[conf[0]][conf[1]].isnumeric():
                    raise InvalidConfValueError(f"Error - Invalid [{conf[0]}][{conf[1]}]: must be numeric - 1234.")
        def check_hex_format(config:ConfigParser, conf_list:list):
            for conf in conf_list:
                if conf[2] and config[conf[0]][conf[1]] == "auto":
                    continue
                if not self.__hex_pattern.fullmatch(config[conf[0]][conf[1]]):
                    raise InvalidConfValueError(f"Error - Invalid [{conf[0]}][{conf[1]}]: must be hex - 0xabcdef.")

        check_numeric_format(config, [
            ("boot.bin", "DiscNumber"),
            ("boot.bin", "GameVersion"),
            ("boot.bin", "StreamBufferSize"),
            ("bi2.bin", "DebugFlag"),
            ("bi2.bin", "TotalDisc")])

        check_hex_format(config, [
            ("boot.bin", "DVDMagic",           False),
            ("boot.bin", "DolOffset",          True),
            ("boot.bin", "FstOffset",          True),
            ("boot.bin", "FstLen",             True),
            ("boot.bin", "FstMaxLen",          True),
            ("boot.bin", "UserPosition",       True),
            ("boot.bin", "UserLength",         True),
            ("bi2.bin", "DebugMonitorSize",    False),
            ("bi2.bin", "SimulatedMemorySize", False),
            ("bi2.bin", "ArgumentOffset",      False),
            ("bi2.bin", "TrackLocation",       False),
            ("bi2.bin", "TrackSize",           False),
            ("bi2.bin", "DolLimit",            False),
            ("apploader.img", "EntryPoint",    False),
            ("apploader.img", "Size",          False),
            ("apploader.img", "TrailerSize",   False)])
        
        self.__bootbin.make_mut()
        self.__bi2bin.make_mut()
        self.__apploaderimg.make_mut()

        conf_value_dol_offset = None
        conf_value_fst_offset = None
        conf_value_fst_len = 0
        conf_value_fst_max_len = None
        conf_value_user_position = None
        conf_value_user_length = None

        if config["Default"]["boot.bin_section"].lower() == "enabled":
            if len(config["boot.bin"]["GameCode"]) != 4:
                raise InvalidConfValueError("Error - Invalid [boot.bin][GameCode]: must be str with length = 4.")
            self.__bootbin.set_game_code( config["boot.bin"]["GameCode"] )
            
            if len(config["boot.bin"]["MakerCode"]) != 2:
                raise InvalidConfValueError("Error - Invalid [boot.bin][MakerCode]: must be str with length = 2.")
            self.__bootbin.set_maker_code( config["boot.bin"]["MakerCode"] )
            
            disc_number = int(config["boot.bin"]["DiscNumber"])
            if disc_number > 98:
                raise InvalidConfValueError("Error - Invalid [boot.bin][DiscNumber]: must be int with value < 99.")
            self.__bootbin.set_disc_number( disc_number )

            game_version = int(config["boot.bin"]["GameVersion"])
            if game_version > 99:
                raise InvalidConfValueError("Error - Invalid [boot.bin][GameVersion]: must be int with value < 100.")
            self.__bootbin.set_game_version( game_version )

            if config["boot.bin"]["AudioStreaming"] not in ["0", "1"]:
                raise InvalidConfValueError("Error - Invalid [boot.bin][AudioStreaming]: this flag must be 0 or 1.")
            self.__bootbin.set_audio_streaming( int(config["boot.bin"]["AudioStreaming"]) )

            stream_buffer_size = int(config["boot.bin"]["StreamBufferSize"])
            if stream_buffer_size > 15:
                raise InvalidConfValueError("Error - Invalid [boot.bin][StreamBufferSize]: must be int with value between 0 and 15.")
            self.__bootbin.set_stream_buffer_size( stream_buffer_size )

            if len(config["boot.bin"]["DVDMagic"]) != 10:
                raise InvalidConfValueError("Error - Invalid [boot.bin][DVDMagic]: must be 8 hex digits begining with 0x.")
            self.__bootbin.set_dvd_magic( int(config["boot.bin"]["DVDMagic"], 16) )
            
            if len(config["boot.bin"]["GameName"]) > 64:
                raise InvalidConfValueError("Error - Invalid [boot.bin][GameName]: must be str with length < 64.")
            self.__bootbin.set_game_name( config["boot.bin"]["GameName"] )

            if config["boot.bin"]["DolOffset"] != "auto":
                dol_offset = int(config["boot.bin"]["DolOffset"], 16)
                if dol_offset > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][DolOffset]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_dol_offset( dol_offset )
                conf_value_dol_offset = dol_offset

            if config["boot.bin"]["FstOffset"] != "auto":
                fst_offset = int(config["boot.bin"]["FstOffset"], 16)
                if fst_offset > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][FstOffset]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_fst_offset( fst_offset )
                conf_value_fst_offset = fst_offset

            if config["boot.bin"]["FstLen"] != "auto":
                fst_len = int(config["boot.bin"]["FstLen"], 16)
                if fst_len > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][FstLen]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_fst_len( fst_len )
                conf_value_fst_len = fst_len

            if config["boot.bin"]["FstMaxLen"] != "auto":
                fst_max_len = int(config["boot.bin"]["FstMaxLen"], 16)
                if fst_max_len > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][FstMaxLen]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_fst_max_len( fst_max_len )
                conf_value_fst_max_len = fst_max_len
        
            if config["boot.bin"]["UserPosition"] != "auto":
                user_position = int(config["boot.bin"]["UserPosition"], 16)
                if user_position > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][UserPosition]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_user_position( user_position )
                conf_value_user_position = user_position
            
            if config["boot.bin"]["UserLength"] != "auto":
                user_length = int(config["boot.bin"]["UserLength"], 16)
                if user_length > 0xffffffff:
                    raise InvalidConfValueError("Error - Invalid [boot.bin][UserLength]: must be auto or unsigned hex value with length < 5 bytes.")
                self.__bootbin.set_user_length( user_length )
                conf_value_user_length = user_length

        if config["Default"]["bi2.bin_section"].lower() == "enabled":
            debug_monitor_size = int(config["bi2.bin"]["DebugMonitorSize"], 16)
            if debug_monitor_size > 0xffffffff or debug_monitor_size & 31:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][DebugMonitorSize]: must be hex value with length < 5 bytes and aligned to 32.")
            self.__bi2bin.set_debug_monitor_size( debug_monitor_size )

            simulated_memory_size = int(config["bi2.bin"]["SimulatedMemorySize"], 16)
            if simulated_memory_size > 0xffffffff or simulated_memory_size & 31:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][SimulatedMemorySize]: must be hex value with length < 5 bytes and aligned to 32.")
            self.__bi2bin.set_simulated_memory_size( simulated_memory_size )

            argument_offset = int(config["bi2.bin"]["ArgumentOffset"], 16)
            if argument_offset > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][ArgumentOffset]: must be hex value with length < 5 bytes.")
            self.__bi2bin.set_argument_offset( argument_offset )

            debug_flag = int(config["bi2.bin"]["DebugFlag"])
            if debug_flag > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][DebugFlag]: must be hex value with length < 5 bytes.")
            self.__bi2bin.set_debug_flag( debug_flag )

            track_location = int(config["bi2.bin"]["TrackLocation"], 16)
            if track_location > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][TrackLocation]: must be hex value with length < 5 bytes.")
            self.__bi2bin.set_track_location( track_location )

            track_size = int(config["bi2.bin"]["TrackSize"], 16)
            if track_size > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][TrackSize]: must be hex value with length < 5 bytes.")
            self.__bi2bin.set_track_size( track_size )

            if config["bi2.bin"]["CountryCode"] not in ["0", "1", "2", "4"]:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][CountryCode]: must have 0, 1, 2 or 4 value.")
            self.__bi2bin.set_country_code( int(config["bi2.bin"]["CountryCode"]) )

            if int(config["bi2.bin"]["TotalDisc"]) > 99:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][TotalDisc]: must between 1 and 99.")
            self.__bi2bin.set_total_disc( int(config["bi2.bin"]["TotalDisc"], 16) )

            if config["bi2.bin"]["LongFileNameSupport"] not in ["0", "1"]:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][LongFileNameSupport]: must be 0 or 1.")
            self.__bi2bin.set_long_file_name_support( int(config["bi2.bin"]["LongFileNameSupport"]) )

            dol_limit = int(config["bi2.bin"]["DolLimit"], 16)
            if dol_limit > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [bi2.bin][DolLimit]: must be hex value with length < 5 bytes.")
            self.__bi2bin.set_dol_limit( dol_limit )

        if config["Default"]["apploader.img_section"].lower() == "enabled":
            version = config["apploader.img"]["Version"]
            if len(version) > 10:
                raise InvalidConfValueError("Error - Invalid [apploader.img][Version]: must be 16 byte ascii string.")
            self.__apploaderimg.set_version( version )

            entry_point = int(config["apploader.img"]["EntryPoint"], 16)
            if entry_point > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [apploader.img][EntryPoint]: must be hex value with length < 5 bytes.")
            self.__apploaderimg.set_entry_point( entry_point )
            
            size = int(config["apploader.img"]["Size"], 16)
            if size > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [apploader.img][Size]: must be hex value with length < 5 bytes.")
            self.__apploaderimg.set_size( size )
            
            trailer_size = int(config["apploader.img"]["TrailerSize"], 16)
            if trailer_size > 0xffffffff:
                raise InvalidConfValueError("Error - Invalid [apploader.img][TrailerSize]: must be hex value with length < 5 bytes.")
            self.__apploaderimg.set_trailer_size( trailer_size )

        (sys_path / "boot.bin").write_bytes(self.__bootbin.data())
        (sys_path / "bi2.bin").write_bytes(self.__bi2bin.data())
        (sys_path / "apploader.img").write_bytes(self.__apploaderimg.data())

        logging.info("sys/sytem.conf loaded.")

        if get_conf_values:
            return (
                conf_value_dol_offset,
                conf_value_fst_offset,
                conf_value_fst_len,
                conf_value_fst_max_len,
                conf_value_user_position,
                conf_value_user_length
            )
    def __get_min_file_offset(self, fstbin_data:bytes):
        "Get the min file offset to check if there is an overflow."
        min_offset = None
        for i in range(2, int.from_bytes(fstbin_data[8:12], "big")):
            if int.from_bytes(fstbin_data[i*12:i*12+1], "big") == FstTree.TYPE_FILE:
                if min_offset is None:
                    min_offset = int.from_bytes(fstbin_data[i*12+4:i*12+8], "big")
                    continue
                min_offset = min(min_offset, int.from_bytes(fstbin_data[i*12+4:i*12+8], "big"))
        return min_offset
    def unpack(self, iso_path:Path, folder_path:Path):
        """
        Unpack takes an GCM/iso file and unpack it in a folder.
        input: iso_path = Path
        input: folder_path = Path
        """
        with iso_path.open("rb") as iso_file:
            self.__bootbin = BootBin(iso_file.read(BootBin.LEN))
            if self.__bootbin.dvd_magic() != Gcm.DVD_MAGIC:
                raise InvalidDVDMagicError("Error - Invalid DVD format - this tool is for ISO/GCM files.")

            self.__bi2bin = Bi2Bin(iso_file.read(Bi2Bin.LEN))

            iso_file.seek(Gcm.APPLOADERLEN_OFFSET)
            size = int.from_bytes(iso_file.read(4), "big")
            trailerSize = int.from_bytes(iso_file.read(4), "big")
            
            apploader_size = Gcm.APPLOADER_HEADER_LEN + size + trailerSize
            
            iso_file.seek(Gcm.APPLOADER_OFFSET)
            self.__apploaderimg = ApploaderImg(iso_file.read(apploader_size))

            fstbin_offset = self.__bootbin.fst_offset()
            fstbin_len = self.__bootbin.fst_len()
            iso_file.seek( fstbin_offset )
            fstbin_data = iso_file.read( fstbin_len )

            dol_offset = self.__bootbin.dol_offset()
            iso_file.seek( dol_offset )
            dol = Dol()
            dolheader_data = iso_file.read(Dol.HEADER_LEN)
            dol_len = dol.get_dol_len( dolheader_data )
            bootdol_data = dolheader_data + iso_file.read( dol_len - Dol.HEADER_LEN )

            if folder_path == Path("."):
                folder_path = Path(f"{self.__bootbin.game_code()}-{self.__bootbin.disc_number():02}")
            if folder_path.is_dir():
                raise InvalidUnpackFolderError(f"Error - \"{folder_path}\" already exist. Remove this folder or use another name for the unpack folder.")
            
            logging.info(f"unpacking \"{iso_path}\" in \"{folder_path}\"")
            sys_path = folder_path / "sys"
            sys_path.mkdir(parents=True)

            logging.debug(f"{iso_path}(0x0:0x{BootBin.LEN:x}) -> {sys_path / 'boot.bin'}")
            (sys_path / "boot.bin").write_bytes(self.__bootbin.data())
            logging.debug(f"{iso_path}(0x440:0x{Gcm.APPLOADER_OFFSET:x}) -> {sys_path / 'bi2.bin'}")
            (sys_path / "bi2.bin" ).write_bytes(self.__bi2bin.data())
            logging.debug(f"{iso_path}(0x{Gcm.APPLOADER_OFFSET:x}:0x{Gcm.APPLOADER_OFFSET + apploader_size:x} -> {sys_path / 'apploader.img'}")
            (sys_path / "apploader.img").write_bytes(self.__apploaderimg.data())
            logging.debug(f"{iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x}) -> {sys_path / 'fst.bin'}")
            (sys_path / "fst.bin").write_bytes(fstbin_data)
            logging.debug(f"{iso_path}(0x{dol_offset:x}:0x{dol_offset + dol_len:x}) -> {sys_path / 'boot.dol'}")
            (sys_path / "boot.dol").write_bytes(bootdol_data)

            # Generate conf from sys files
            self.__save_conf(sys_path)

            root_path = folder_path / "root"
            root_path.mkdir()
            
            # And now we parse FST data to unpack all files in the GCM iso file
            dir_id_path = {0: root_path}
            currentdir_path = root_path

            # root: id=0 so nextdir is the end
            nextdir = int.from_bytes(fstbin_data[8:12], "big")
            # offset of filenames block
            base_names = nextdir * 12
            # go to parent when id reach next dir
            nextdir_arr = [ nextdir ]

            for id in range(1, base_names // 12):
                i = id * 12
                file_type = int.from_bytes(fstbin_data[i:i+1], "big")
                name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big"):].split(b"\x00")[0].decode("utf-8")
                
                while id == nextdir_arr[-1]:
                    currentdir_path = currentdir_path.parent
                    nextdir_arr.pop()

                if file_type == FstTree.TYPE_DIR:
                    nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big")
                    parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big")

                    nextdir_arr.append( nextdir )
                    currentdir_path = dir_id_path[parentdir] / name
                    dir_id_path[id] = currentdir_path
                    currentdir_path.mkdir(exist_ok=True)
                else:
                    fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big")
                    filesize   = int.from_bytes(fstbin_data[i+8:i+12], "big")

                    iso_file.seek(fileoffset)
                    (currentdir_path / name).write_bytes( iso_file.read(filesize) )

                    logging.debug(f"{iso_path}(0x{fileoffset:x}:0x{fileoffset + filesize:x}) -> {currentdir_path / name}")
    def pack(self, folder_path:Path, iso_path:Path = None, disable_ignore:bool = False, skip_conf:bool = False):
        """
        Pack takes a folder unpacked by the pack command and pack it in a GCM/iso file.
        input: folder_path = Path
        input: iso_path = Path
        """
        if iso_path is None:
            iso_path = folder_path.parent / Path(folder_path.name).with_suffix(".iso")
        if iso_path.is_file():
            raise InvalidPackIsoError(f"Error - {iso_path} already exist. Remove this file or use another GCM file name.")

        try:
            with iso_path.open("wb") as iso_file:
                sys_path = folder_path / "sys"
                
                self.__bootbin = BootBin((sys_path / "boot.bin").read_bytes())
                self.__bi2bin = Bi2Bin((sys_path / "bi2.bin").read_bytes())
                self.__apploaderimg = ApploaderImg((sys_path / "apploader.img").read_bytes())

                # Patch boot.bin bi2.bin and apploader.img if system.conf is enabled
                if not skip_conf:
                    self.__load_conf(sys_path)
                if self.__bootbin.fst_len() > self.__bootbin.fst_max_len():
                    raise InvalidFSTSizeError(f"Error - fst.bin max length < fst.bin length in boot.bin offset 0x{BootBin.FSTMAXLEN_OFFSET:x}:0x{BootBin.FSTMAXLEN_OFFSET+4:x}.")

                logging.debug(f"{sys_path / 'boot.bin'}      -> {iso_path}(0x0:0x{BootBin.LEN:x})")
                iso_file.write(self.__bootbin.data())
                logging.debug(f"{sys_path / 'bi2.bin'}       -> {iso_path}(0x{BootBin.LEN:x}:0x{Gcm.APPLOADER_OFFSET:x})")
                iso_file.write(self.__bi2bin.data())

                apploader_end_offset = Gcm.APPLOADER_OFFSET + self.__apploaderimg.len()
                logging.debug(f"{sys_path / 'apploader.img'} -> {iso_path}(0x{Gcm.APPLOADER_OFFSET:x}:0x{apploader_end_offset:x}")
                iso_file.write(self.__apploaderimg.data())

                fstbin_offset = self.__bootbin.fst_offset()
                fstbin_len = self.__bootbin.fst_len()
                fstbin_end_offset = fstbin_offset + fstbin_len
                if (sys_path / "fst.bin").stat().st_size != fstbin_len:
                    raise InvalidFSTSizeError(f"Error - Invalid fst.bin length in boot.bin offset 0x{BootBin.FSTLEN_OFFSET:x}:0x{BootBin.FSTLEN_OFFSET+4:x}.")
                logging.debug(f"{sys_path / 'fst.bin'}       -> {iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x})")
                iso_file.seek( fstbin_offset )
                fstbin_data = (sys_path / "fst.bin").read_bytes()
                iso_file.write( fstbin_data )
                
                dol_offset = self.__bootbin.dol_offset()
                dol_end_offset = dol_offset + (sys_path / 'boot.dol').stat().st_size

                min_file_offset = self.__get_min_file_offset(fstbin_data)

                # FST can be before the dol or after
                # We control values to avoid Overflows
                if not disable_ignore:
                    if not Gcm.APPLOADER_OFFSET < dol_offset < dol_end_offset <= fstbin_offset and not \
                        fstbin_offset < dol_offset < dol_end_offset <= min_file_offset:
                        raise DolSizeOverflowError("Error - The dol length has been increased and overflow on next file or on FST. To solve this check the sys/system.conf file if used or use --rebuild-fst.")

                if not Gcm.APPLOADER_OFFSET < fstbin_offset < fstbin_end_offset <= dol_offset and not \
                    dol_end_offset <= fstbin_offset < fstbin_end_offset <= min_file_offset:
                    raise FstSizeOverflowError("Error - The FST length has been increased and overflow on next file or on dol. To solve this check the sys/system.conf file if used or use --rebuild-fst.")

                if Gcm.APPLOADER_OFFSET < dol_offset < apploader_end_offset or \
                    Gcm.APPLOADER_OFFSET < fstbin_offset < apploader_end_offset:
                    raise ApploaderOverflowError("Error - The apploader length has been increased and overflow on dol or on FST. To solve this check the sys/system.conf file if used or use --rebuild-fst.")

                logging.debug(f"{sys_path / 'boot.dol'}      -> {iso_path}(0x{dol_offset:x}:0x{dol_end_offset:x})")
                iso_file.seek( dol_offset )
                iso_file.write( (sys_path / "boot.dol").read_bytes() )

                # Now parse fst.bin for writing files in the iso
                dir_id_path = {0: folder_path / "root"}
                currentdir_path = folder_path / "root"

                # root: id=0 so nextdir is the end
                nextdir = int.from_bytes(fstbin_data[8:12], "big")
                # offset of filenames block
                base_names = nextdir * 12
                # go to parent when id reach next dir
                nextdir_arr = [ nextdir ]

                # Check if there is new / removed files or dirs in the root folder
                if nextdir - 1 != len(list(currentdir_path.glob("**/*"))):
                    raise InvalidRootFileFolderCountError(f"Error - Invalid file & folders count inside {currentdir_path}. Use --rebuild-fst to update the FST before packing.")

                for id in range(1, base_names // 12):
                    i = id * 12
                    file_type = int.from_bytes(fstbin_data[i:i+1], "big")
                    name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big"):].split(b"\x00")[0].decode("utf-8")
                    
                    while id == nextdir_arr[-1]:
                        currentdir_path = currentdir_path.parent
                        nextdir_arr.pop()

                    if file_type == FstTree.TYPE_DIR:
                        nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big")
                        parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big")

                        nextdir_arr.append( nextdir )
                        currentdir_path = dir_id_path[parentdir] / name
                        dir_id_path[id] = currentdir_path
                        if not currentdir_path.is_dir():
                            raise FSTDirNotFoundError(f"Error - FST dir {currentdir_path} not found in the root directory. "
                                "The dir has been removed or renamed. Use --rebuild-fst to update the FST and avoid this error."
                                "Warning: DVD SDK use dirnames to load files from the GCM/iso.")
                    else:
                        if not (currentdir_path / name).is_file():
                            raise FSTFileNotFoundError(f"Error - FST file {currentdir_path / name} not found in the root directory. "
                                "The file has been removed or renamed. Use --rebuild-fst to update the FST and avoid this error."
                                "Warning: DVD SDK use filenames to load files from the GCM/iso.")
                        
                        file_offset = int.from_bytes(fstbin_data[i+4:i+8], "big")
                        file_len   = int.from_bytes(fstbin_data[i+8:i+12], "big")

                        if (currentdir_path / name).stat().st_size != file_len:
                            raise InvalidFSTFileSizeError(f"Error - Invalid file length: {currentdir_path / name} - use --rebuild-fst before packing files in the iso.")
                        logging.debug(f"{currentdir_path / name} -> {iso_path}(0x{file_offset:x}:0x{file_offset + file_len:x})")
                        iso_file.seek(file_offset)
                        iso_file.write( (currentdir_path / name).read_bytes() )
        except (InvalidFSTSizeError, DolSizeOverflowError, InvalidRootFileFolderCountError, InvalidFSTFileSizeError, \
            FSTDirNotFoundError, FSTFileNotFoundError, InvalidConfValueError, FstSizeOverflowError, ApploaderOverflowError):
            iso_path.unlink()
            raise
    def rebuild_fst(self, folder_path:Path, align:int, skip_conf:bool):
        """
        Rebuild FST generate a new file system by using all files in the root folder
        it patch boot.bin caracteristics, apploader.img and also file system changes.
        Game dol use FST filenames to find files so be carrefull when changing the 
        root filesystem. Align is 0x8000 for APDCM.
        input: folder_path = Path
        input: align = int
        """
        root_path = folder_path / "root"
        sys_path = folder_path / "sys"

        self.__bootbin = BootBin((sys_path / "boot.bin").read_bytes())
        self.__bi2bin = Bi2Bin((sys_path / "bi2.bin").read_bytes())
        self.__apploaderimg = ApploaderImg((sys_path / "apploader.img").read_bytes())

        (
            dol_offset,
            fst_offset,
            fst_len,
            fst_max_len,
            user_position,
            user_length
        ) = self.__load_conf(sys_path, get_conf_values = True) if not skip_conf else (None, None, 0, None, None, None)

        if dol_offset is None:
            dol_offset = align_top(Gcm.APPLOADER_OFFSET + (sys_path / "apploader.img").stat().st_size, align)
            logging.info(f"Patching sys/boot.bin offset 0x{BootBin.DOLOFFSET_OFFSET:x} with new dol offset (0x{dol_offset:x}).")
            self.__bootbin.set_dol_offset(dol_offset)

        dol_end_offset = align_top(dol_offset + (sys_path / "boot.dol").stat().st_size, align)
        # Default = FST after dol
        if fst_offset is None:
            fst_offset = dol_end_offset
            logging.info(f"Patching sys/boot.bin offset 0x{BootBin.FSTOFFSET_OFFSET:x} with new FST offset (0x{fst_offset:x}).")
            self.__bootbin.set_fst_offset(fst_offset)
        
        fst_end_offset = fst_offset + fst_len
        fst_tree = FstTree(root_path, max(dol_end_offset, fst_offset, fst_end_offset), \
            is_fst_last = (dol_end_offset <= fst_offset and fst_len == 0), align=align)

        # Sorting paths approach original fst sort, but in original fst specials chars are after and not before chars.
        # Files / Folders are sometimes put in arbitrary order.
        path_list = sorted([path for path in root_path.glob('**/*')], key=lambda s:Path(str(s).upper()))
        for path in path_list:
            fst_tree.add_node_by_path(path)
        logging.debug(fst_tree)

        fst_path = sys_path / "fst.bin"

        logging.info(f"Writing fst in sys/fst.bin")
        fst_path.write_bytes( fst_tree.generate_fst() )

        if fst_len == 0:
            fst_len = fst_path.stat().st_size
            logging.info(f"Patching sys/boot.bin offset 0x{BootBin.FSTLEN_OFFSET:x} with new FST size (0x{fst_len:x}).")
            self.__bootbin.set_fst_len(fst_len)

        if fst_max_len is None and fst_len > self.__bootbin.fst_max_len():
            logging.info(f"Patching sys/boot.bin offset 0x{BootBin.FSTMAXLEN_OFFSET:x} with new FST max size (0x{fst_len:x}).")
            self.__bootbin.set_fst_max_len(fst_len)

        if user_position is None:
            # Allow fixed fst_len or dol after FST fixed by conf
            user_position = max(fst_tree.user_position(), fst_offset + fst_len, dol_end_offset)
            logging.info(f"Patching sys/boot.bin offset 0x434 with new user position (0x{user_position:x}).")
            self.__bootbin.set_user_position(user_position)
        
        if user_length is None:
            user_length = fst_tree.user_length()
            logging.info(f"Patching sys/boot.bin offset 0x438 with new user length (0x{user_length:x}).")
            self.__bootbin.set_user_length(user_length)

        (sys_path / "boot.bin").write_bytes(self.__bootbin.data())
    def __get_sys_from_folder(self, folder_path:Path):
        """
        Load system files from an unpacked GCM/iso folder and returns informations for the stats command.
        input: folder_path = Path
        return (dol_len:int, fstbin_data:bytes)
        load __bootbin, __bi2bin, __apploaderimg
        """
        sys_path = folder_path / "sys"
        self.__bootbin = BootBin((sys_path / "boot.bin").read_bytes())
        self.__bi2bin = Bi2Bin((sys_path / "bi2.bin").read_bytes())
        self.__apploaderimg = ApploaderImg((sys_path / "apploader.img").read_bytes())

        dol_len = (sys_path / "boot.dol").stat().st_size
        fstbin_data = (sys_path / "fst.bin").read_bytes()
        return (dol_len, fstbin_data)
    def __get_sys_from_file(self, file_path:Path):
        """
        Load system files from a GCM/iso file and returns informations for the stats command.
        input: folder_path = Path
        return (dol_len:int, fstbin_data:bytes)
        load __bootbin, __bi2bin, __apploaderimg
        """
        dol_len = None
        fstbin_data = None
        with file_path.open("rb") as iso_file:
            self.__bootbin = BootBin(iso_file.read(BootBin.LEN))
            self.__bi2bin = Bi2Bin(iso_file.read(Bi2Bin.LEN))
            
            iso_file.seek(Gcm.APPLOADERLEN_OFFSET)
            apploader_size = Gcm.APPLOADER_HEADER_LEN + int.from_bytes(iso_file.read(4), "big") + int.from_bytes(iso_file.read(4), "big")
            iso_file.seek(Gcm.APPLOADER_OFFSET)
            self.__apploaderimg = ApploaderImg(iso_file.read(apploader_size))

            dol = Dol()
            iso_file.seek( self.__bootbin.dol_offset() )
            dol_len = dol.get_dol_len( iso_file.read(Dol.HEADER_LEN) )
            iso_file.seek( self.__bootbin.fst_offset() )
            fstbin_data = iso_file.read(self.__bootbin.fst_len())
        return (dol_len, fstbin_data)
    def stats(self, path:Path, align:int = 4):
        """
        Print SYS files informations, global memory mapping, empty spaces inside the GCM/iso
        input:
        * path = Path (folder or iso/GCM file)
        * align = int
        """
        (dol_len, fstbin_data) = self.__get_sys_from_folder(path) if path.is_dir() else self.__get_sys_from_file(path)

        global_stats = f"# Stats for \"{path}\":\n\n" + \
            "[boot.bin]\n" + \
            f"GameCode = {self.__bootbin.game_code()}\n" + \
            f"MakerCode = {self.__bootbin.maker_code()}\n" + \
            f"DiscNumber = {self.__bootbin.disc_number()}\n" + \
            f"GameVersion = {self.__bootbin.game_version()}\n" + \
            f"AudioStreaming = {self.__bootbin.audio_streaming()}\n" + \
            f"StreamBufferSize = {self.__bootbin.stream_buffer_size()}\n" + \
            f"DVDMagic = 0x{self.__bootbin.dvd_magic().hex()}\n" + \
            f"GameName = {self.__bootbin.game_name()}\n" + \
            f"DolOffset = 0x{self.__bootbin.dol_offset():x}\n" + \
            f"FstOffset = 0x{self.__bootbin.fst_offset():x}\n" + \
            f"FstLen = 0x{self.__bootbin.fst_len():x}\n" + \
            f"FstMaxLen = 0x{self.__bootbin.fst_max_len():x}\n" + \
            f"UserPosition = 0x{self.__bootbin.user_position():x}\n" + \
            f"UserLength = 0x{self.__bootbin.user_length():x}\n\n" + \
            "[bi2.bin]\n" + \
            f"DebugMonitorSize = 0x{self.__bi2bin.debug_monitor_size():x}\n" + \
            f"SimulatedMemorySize = 0x{self.__bi2bin.simulated_memory_size():x}\n" + \
            f"ArgumentOffset = 0x{self.__bi2bin.argument_offset():x}\n" + \
            f"DebugFlag = {self.__bi2bin.debug_flag()}\n" + \
            f"TrackLocation = 0x{self.__bi2bin.track_location():x}\n" + \
            f"TrackSize = 0x{self.__bi2bin.track_size():x}\n" + \
            f"CountryCode = {self.__bi2bin.country_code()}\n" + \
            f"TotalDisc = {self.__bi2bin.total_disc()}\n" + \
            f"LongFileNameSupport = {self.__bi2bin.long_file_name_support()}\n" + \
            f"DolLimit = 0x{self.__bi2bin.dol_limit():x}\n\n" + \
            "[apploader.img]\n" + \
            f"Version = {self.__apploaderimg.version()}\n" + \
            f"EntryPoint = 0x{self.__apploaderimg.entry_point():x}\n" + \
            f"Size = 0x{self.__apploaderimg.size():x}\n" + \
            f"TrailerSize = 0x{self.__apploaderimg.trailer_size():x}\n"

        print(global_stats)

        class MemoryObject:
            def __init__(self, name:str, beg_offset:int, length:int):
                self.name = name
                self.beg_offset = beg_offset
                self.length = length
                self.end_offset = beg_offset + length
            def __str__(self):
                return f"| {self.beg_offset:08x} | {self.end_offset:08x} | {self.length:08x} | {self.name}"

        mem_obj_list = [
            MemoryObject("boot.bin", 0, BootBin.LEN),
            MemoryObject("bi2.bin", 0x440, Bi2Bin.LEN),
            MemoryObject("apploader.img", Gcm.APPLOADER_OFFSET, self.__apploaderimg.len()),
            MemoryObject("fst.bin", self.__bootbin.fst_offset(), self.__bootbin.fst_len()),
            MemoryObject("boot.dol", self.__bootbin.dol_offset(), dol_len)]

        dir_id_path = {0: Path(".")}
        currentdir_path = Path(".")

        # root: id=0 so nextdir is the end
        nextdir = int.from_bytes(fstbin_data[8:12], "big")
        # offset of filenames block
        base_names = nextdir * 12
        # go to parent when id reach next dir
        nextdir_arr = [ nextdir ]

        for id in range(1, base_names // 12):
            i = id * 12
            file_type = int.from_bytes(fstbin_data[i:i+1], "big")
            name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big"):].split(b"\x00")[0].decode("utf-8")
            
            while id == nextdir_arr[-1]:
                currentdir_path = currentdir_path.parent
                nextdir_arr.pop()

            if file_type == FstTree.TYPE_DIR:
                nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big")
                parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big")

                nextdir_arr.append( nextdir )
                currentdir_path = dir_id_path[parentdir] / name
                dir_id_path[id] = currentdir_path
            else:
                fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big")
                filesize   = int.from_bytes(fstbin_data[i+8:i+12], "big")
                mem_obj_list.append( MemoryObject(str(currentdir_path / name), fileoffset, filesize) )

        mem_obj_list.sort(key=lambda x: x.beg_offset)

        empty_space_list = []
        collision_list = []
        last_mem_obj = mem_obj_list[2]
        for mem_obj in mem_obj_list[3:]:
            last_aligned = align_top(last_mem_obj.end_offset, align)
            if last_aligned < mem_obj.beg_offset:
                empty_space_list.append( MemoryObject("", last_aligned, mem_obj.beg_offset - last_aligned) )
            elif last_aligned > mem_obj.beg_offset:
                collision_list += [last_mem_obj, mem_obj]
            last_mem_obj = mem_obj
        
        self.__print("Global memory mapping:", mem_obj_list)
        if empty_space_list:
            self.__print(f"Empty spaces (align={align}):", empty_space_list)
        if collision_list:
            self.__print(f"Collisions (align={align}):", collision_list)
    def __print(self, title:str, mem_obj_list):
        """
        Print a table with a title.
        * input: title = str
        * input: mem_obj_list = [MemoryObject, ...]
        """
        full_title = "#"*70+f"\n# {title}\n"+"#"*70+"\n| b offset | e offset | length   | Name\n|"+"-"*69+"\n"
        print(full_title + "\n".join([str(mem_obj) for mem_obj in mem_obj_list]))


def pack(p_input:Path, p_output:Path, disable_ignore:bool, skip_conf:bool = False):
    logging.info("### Pack in new GCM iso")
    if(p_output == Path(".")):
        p_output = Path(p_input.with_suffix(".iso"))
    logging.info(f"Packing folder \"{p_input}\" in \"{p_output}\"")
    gcm.pack(p_input, p_output, disable_ignore, skip_conf)


def unpack(p_input:Path, p_output:Path):
    logging.info("### Unpack GCM iso in new folder")
    gcm.unpack(p_input, p_output)


def rebuild_fst(p_input:Path, align:int, skip_conf:bool = False):
    logging.info("### Rebuilding FST and patching boot.bin")
    if args.align < 1:
        raise BadAlignError("Error - Align must be > 0.")
    logging.info(f"Using alignment: {args.align}")
    gcm.rebuild_fst(p_input, align, skip_conf)


def get_argparser():
    import argparse
    parser = argparse.ArgumentParser(description='ISO/GCM packer & unpacker - [GameCube] v' + __version__)
    parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
    parser.add_argument('-v', '--verbose', action='store_true', help='verbose mode')
    parser.add_argument('-a', '--align', type=int, help='-a=10: alignment of files in the GCM ISO (default value is 4)', default=4)
    parser.add_argument('-di', '--disable-ignore', action='store_true', help='-di: disable dol collisions verification when packing files sharing the same place in the GCM.')
    parser.add_argument('input_path', metavar='INPUT', help='')
    parser.add_argument('output_path', metavar='OUTPUT', help='', nargs='?', default="")

    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument('-p', '--pack', action='store_true', help="-p source_folder (dest_file.iso): Pack source_folder in new file source_folder.iso or dest_file.iso if specified.")
    group.add_argument('-u', '--unpack', action='store_true', help="-u source_iso.iso (dest_folder): Unpack the GCM/ISO in new folder source_iso or dest_folder if specified.")
    group.add_argument('-s', '--stats', action='store_true', help="-s source_iso.iso or source_folder (-a 4): Get stats about GCM, FST, memory, lengths and offsets.")
    group.add_argument('-r', '--rebuild-fst', action='store_true', help="-r game_folder (-a 4): Rebuild the game_folder/sys/fst.bin using files in game_folder/root. For ADPCM (...) use 0x8000 align.")
    group.add_argument('-ur', '--unpack-rebuild-fst', action='store_true', help="-ur source_iso.iso (dest_folder) (-a 4): Unpack and rebuild the FST.")
    group.add_argument('-rp', '--rebuild-fst-pack', action='store_true', help="-rp source_folder (dest_file.iso) (-a 4): Rebuild the FST and pack.")
    return parser


if __name__ == '__main__':
    logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
    args = get_argparser().parse_args()

    p_input = Path(args.input_path)
    p_output = Path(args.output_path)

    gcm = Gcm()
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)

    if args.pack:
        pack(p_input, p_output, args.disable_ignore)
    elif args.unpack:
        unpack(p_input, p_output)
    elif args.stats:
        gcm.stats(p_input)
    elif args.rebuild_fst:
        rebuild_fst(p_input, args.align)
    elif args.rebuild_fst_pack:
        rebuild_fst(p_input, args.align) # rebuild fst parse and patch with conf
        pack(p_input, p_output, args.disable_ignore, skip_conf = True)
    elif args.unpack_rebuild_fst:
        unpack(p_input, p_output) # conf isn't enabled yet
        rebuild_fst(p_output, args.align, skip_conf = True)