from enum import Enum, IntFlag

# Isso são flags.
# Significa que mais de um valor pode ser possível aqui.
class FileMode(IntFlag):
    # O modo do arquivo
    # Quando você dá `ls -l` no terminal, tem um monte de rwxrwxrwx. 
    # Isso é codificado aqui.'
    # O significado está claro se você manja um pouco de inglês. 
    # Se não, separa as duas palavras e joga no google tradutor que vai estar 
    # correto.

    OtherExec = 1
    OtherWrite = 2
    OtherRead = 4

    GroupExec = 8
    GroupWrite = 16
    GroupRead = 32

    OwnerExec = 64
    OwnerWrite = 128
    OwnerRead = 256

    SetGid = 1024
    SetUid = 2048

class FileType(Enum):
    ## O tipo de arquivo

    # Um arquivo comum
    Regular = 0            

    # Um link pra outro arquivo
    Link = 1

    # Um link simbólico. Esse valor está depreciado e não é usado
    Symlink = 2

    # Se você sabe o que são essas duas coisas abaixo, então você sabe o que 
    # significa tudo aqui nesse enum, e não está nem lendo esses comentários.
    CharacterDevice = 3
    BlockDevice = 4

    # Representa uma pasta. Uma coisa engraçada é que, dentro do arquivo tar, 
    # logo depois da pasta,  vêm os arquivos que estão dentro dela. 
    # Isso pode ser útil pra você.
    Directory = 5

    # Se você sabe o que é isso daqui, então você nem precisa desses comentários
    FIFOPipe = 6

    # Campo reservado.
    Reserved = 7

    # Como converter do valor do arquivo pro valor do enum
    # O `val` é o caractere que vem do arquivo.
    @staticmethod
    def from_value(val):
        selections = {
            "0": FileType.Regular,
            "\0": FileType.Regular,
            "1": FileType.Link,
            "2": FileType.Symlink,
            "3": FileType.CharacterDevice,
            "4": FileType.BlockDevice,
            "5": FileType.Directory,
            "6": FileType.FIFOPipe,
            "7": FileType.Reserved
        }

        return selections.get(val, FileType.Reserved)

# Isso aqui embaixo vem no final:

# Lê uma string do arquivo
def read_string(value):
    return value.decode('utf-8').rstrip('\x00 ')

# Lê um número do arquivo. Ele está em octal, então devemos converter.
def read_number(value, default=None):
    try:
        return int(read_string(value), base=8)
    except ValueError:
        return default

## Coloque isso no começo do arquivo, antes do `from enum`
from dataclasses import dataclass

## Isso aqui embaixo vem no final:

# O tamanho do bloco:
BLOCK_SIZE = 512

@dataclass
class TarFile:
    # Você já conhece esses campos :)
    name: str
    mode: FileMode
    uid: int
    gid: int
    size: int
    mtime: dt.datetime
    checksum: int
    typeflag: FileType
    linkname: str
    magic: str
    version: int
    uname: str
    gname: str
    devmajor: int
    devminor: int
    prefix: str

    # O offset do arquivo que segue esse header, pra gente poder ler ele
    # depois
    offset: int

    # O offset do próprio header.
    header: int

    def read_file(self, fileobject):
        # Lê o conteúdo do arquivo que esse header representa
        tell = fileobject.tell()

        fileobject.seek(self.offset)
        data = fileobject.read(self.size)
        fileobject.seek(tell)

        return data

    def get_header_offset(self):
        return self.offset - BLOCK_SIZE

    def verify_checksum(self, fileobject):
        # Verifica o checksum desse header, pra ver se ele é válido ou não.
        tell = fileobject.tell()

        fileobject.seek(self.get_header_offset())
        data = fileobject.read(BLOCK_SIZE)

        checksum = sum([v if i not in range(148, 156) else ord(' ')
                        for i, v in enumerate(data)])

        fileobject.seek(tell)

        return checksum == self.checksum

    @staticmethod
    def from_file(fileobject):
        # Lê um arquivo.
        #
        # Esse `fileobject` é um objeto de arquivo, gerado pelo método `open`, ou
        # por qualquer método que represente um arquivo, como `GzipFile` e outros
        # similares.
        #
        # Esse método vai alterar o fileobject, fazendo ele apontar pro próximo 
        # bloco, que na maior parte das vezes vai ser o conteúdo do arquivo.

        offset = fileobject.tell()

        name = read_string(fileobject.read(100))
        if name == "":
            return None

        mode = FileMode(read_number(fileobject.read(8)))
        uid = read_number(fileobject.read(8))
        gid = read_number(fileobject.read(8))
        size = read_number(fileobject.read(12))
        mtime = dt.datetime.fromtimestamp(read_number(fileobject.read(12)))
        checksum = read_number(fileobject.read(8))
        typeflag = FileType.from_value(read_string(fileobject.read(1)))
        linkname = read_string(fileobject.read(100))

        magic = read_string(fileobject.read(6))
        version = read_number(fileobject.read(2), 0)

        if not magic.startswith("ustar"):
            raise ValueError(f"Invalid header at offset {offset}")

        uname = read_string(fileobject.read(32))
        gname = read_string(fileobject.read(32))
        devmajor = read_number(fileobject.read(8))
        devminor = read_number(fileobject.read(8))
        prefix = fileobject.read(155)

        pad = fileobject.read(12)

        return TarFile(name, mode, uid, gid, size, mtime, checksum, typeflag, 
                       linkname, magic, version, uname, gname, devmajor, devminor,
                       prefix, offset + BLOCK_SIZE, offset)