/*
Student No.: 111550046
Student Name: 周哲煒
Email: chou.cs11@nycu.edu.tw
SE tag: xnxcxtxuxoxsx
Statement: I am fully aware that this program is not supposed to be
posted to a public server, such as a public GitHub repository or a
public web page.
*/

#define FUSE_USE_VERSION 30

#include <fuse.h>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fcntl.h>
#include <vector>
#include <string>
#include <map>
#include <sys/stat.h>
#include <unistd.h>

// Tar entry structure
struct TarEntry {
    std::string name;
    mode_t mode;
    size_t size;
    size_t offset;
    size_t mtime; // Modification time
    size_t uid; // User ID
    size_t gid; // Group ID
    std::string linkname; // For symbolic links
};

std::map<std::string, TarEntry> tar_entries;
const char *tar_file = "test.tar"; // Hardcoded filename

//tohex
std::string tooct(int n){
    std::string oct;
    while(n!=0){
        oct = std::to_string(n%8) + oct;
        n = n/8;
    }
    return oct;
}


// Helper: Parse the tar file and populate tar_entries
void parse_tar_file() {
    FILE *file = fopen(tar_file, "rb");
    if (!file) {
        perror("Failed to open tar file");
        exit(EXIT_FAILURE);
    }

    char header[512];
    size_t offset = 0;

    while (fread(header, 512, 1, file)) {
        if (header[0] == '\0') break; // End of tar file

        // Get metadata from header
        TarEntry entry;
        entry.name = std::string(header, 100).c_str(); // Null-terminated
        entry.mode = strtol(std::string(header + 100, 8).c_str(), nullptr, 8);
        entry.uid = strtol(std::string(header + 108, 8).c_str(), nullptr, 8);
        entry.gid = strtol(std::string(header + 116, 8).c_str(), nullptr, 8);
        entry.size = strtol(std::string(header + 124, 12).c_str(), nullptr, 8);
        entry.mtime = strtol(std::string(header + 136, 12).c_str(), nullptr, 8);
        entry.offset = offset + 512;
        entry.linkname = std::string(header + 157, 100).c_str();

        /** /
        // Check if it's a directory (name ends with '/')
        if (entry.name.back() == '/') {
            std::cout<<entry.name << "is Directory\n";
            entry.size = 0; // Directories have size 0
        }
        /**/
        // std::cout<<"------------\n"<<
        // "name: "<<entry.name<<"\n"<<
        // "mode: "<<tooct(entry.mode)<<"\n"<<
        // "size: "<<entry.size<<"\n"<<
        // "mtime: "<<entry.mtime<<"\n"<<
        // "uid: "<<tooct(entry.uid)<<"\n"<<
        // "gid: "<<tooct(entry.gid)<<"\n"<<
        // "offset: "<<entry.offset<<"\n"<<
        // "linkname: "<<entry.linkname<<"\n"<<
        // "------------\n";

        // Store in map
        if(entry.name.back() == '/') {
            tar_entries["/" + entry.name.substr(0, entry.name.length()-1)] = entry;
        }else{
            tar_entries["/" + entry.name] = entry;
        }

        // Skip to next header
        size_t block_size = ((entry.size + 511) / 512) * 512;
        fseek(file, block_size, SEEK_CUR);
        offset += 512 + block_size;
    }

    fclose(file);

    // std::cout<<"parse_tar_file Done\n";
    // for (const auto &entry : tar_entries) {
    //     std::cout<<"entry: "<<entry.first<<",,,"<<entry.second.name<<",,,"<<entry.second.mode<<",,,"<<entry.second.size<<",,,"<<entry.second.offset<<",,,"<<entry.second.linkname<<"\n";
    // }
}


// FUSE: getattr
// Get file attributes, called when accessing a file or directory
int my_getattr(const char *path, struct stat *st) {
    memset(st, 0, sizeof(struct stat));
    // std::cout << "getattr: " << path << "\n";
    if (strcmp(path, "/") == 0) {
        // Root directory
        st->st_mode = S_IFDIR | 0444; // Read-only directory
        st->st_uid = getuid();
        st->st_gid = getgid();
        st->st_mtime = 0;
        st->st_size = 0;

    } else if (tar_entries.count(path)) {
        // File or directory in tar
        const TarEntry &entry = tar_entries[path];
        // std::cout<< "go through: "<<tar_entries[path].name<<"\n";
        if (entry.name.back() == '/') {
            st->st_mode = S_IFDIR | entry.mode; // Directory
            st->st_uid = entry.uid;
            st->st_gid = entry.gid;
            st->st_mtime = entry.mtime;
            st->st_size = 0;
            // std::cout << "Directory|" << entry.name << "|"<<tooct(st->st_mode) << "|" << st->st_nlink << "|" << st->st_size << "\n";
        } else if(!entry.linkname.empty()) {
            // std::cout<< entry.linkname<<"\n";
            st->st_mode = S_IFLNK | entry.mode; // Symbolic link
            st->st_uid = entry.uid;
            st->st_gid = entry.gid;
            st->st_mtime = entry.mtime;
            st->st_size = entry.size;
            // std::cout << "Symbolic Link|" << entry.name << "|"<<tooct(st->st_mode) << "|" << st->st_nlink << "|" << st->st_size << "\n";
        } else {
            st->st_mode = S_IFREG| entry.mode;
            st ->st_uid = entry.uid;
            st ->st_gid = entry.gid;
            st->st_mtime = entry.mtime;
            st->st_size = entry.size;
            // std::cout << "File|" << entry.name << "|"<<tooct(st->st_mode) << "|" << st->st_nlink << "|" << st->st_size << "\n";
        }
    } else {
        // std::cout<<"Not found\n";
        return -ENOENT; // Not found
    }
    return 0;
}


// FUSE: readdir
// List directory contents, called when listing files in a directory
int my_readdir(const char *path, void *buffer, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) {
    // std::cout<<"my_readdir\t"<< "path: "<<path<<"\n";
    filler(buffer, ".", nullptr, 0);  // Current directory
    filler(buffer, "..", nullptr, 0); // Parent directory

    std::string prefix = std::string(path) + (strcmp(path, "/") == 0 ? "" : "/");

    for (const auto &entry : tar_entries) {
        const std::string &entry_name = entry.first;
        if (entry_name.find(prefix) == 0) { // Starts with prefix
            std::string relative_path = entry_name.substr(prefix.length());
            //std::cout<<" go through:"<< relative_path<<"\n";
            if (relative_path.find('/') == std::string::npos) {
                // Immediate child (no additional '/')
                filler(buffer, relative_path.c_str(), nullptr, 0);
                // std::cout<<"add: "<<relative_path<<"\n";
            }
            /**/
            //dir itself
            else if (relative_path.find_first_of('/') == relative_path.length()-1){
                filler(buffer, relative_path.substr(0,relative_path.length()-1).c_str(), nullptr, 0);
                // std::cout<<"add: "<<relative_path<<"\n";
            }
            /**/
        }
    }

    return 0;
}


// FUSE: read
// Read file contents, called when reading a file
int my_read(const char *path, char *buffer, size_t size, off_t offset, struct fuse_file_info *fi) {
    // std::cout<<"my_read"<< "path: "<<path<<"/"<<"buffer: "<<buffer<<"/"<<"size: "<<size<<"/"<<"offset: "<<offset<<"/"<<"fi: "<<fi<<"\n";
    if (!tar_entries.count(path)) return -ENOENT; // Not found

    const TarEntry &entry = tar_entries[path];
    FILE *file = fopen(tar_file, "rb");
    if (!file) return -EIO; // Failed to open tar

    fseek(file, entry.offset + offset, SEEK_SET);
    size_t bytes_read = fread(buffer, 1, size, file);
    fclose(file);

    return bytes_read;
}

// FUSE: readlink
// Read symbolic link target, called when reading a symbolic link
int my_readlink(const char *path, char *buffer, size_t size) {
    if (!tar_entries.count(path)) return -ENOENT; // Not found

    const TarEntry &entry = tar_entries[path];
    strncpy(buffer, entry.linkname.c_str(), size - 1);
    buffer[size - 1] = '\0'; // Ensure null termination
    return 0;
}

// Main function
int main(int argc, char *argv[]) {
    parse_tar_file();
    // std::cout<<"\033c";
    for (const auto &entry : tar_entries) {
        // std::cout<<"entry: "<<entry.first<<"|"<<entry.second.name<<"\n";
    }
    // std::cout<<"-----------------\n";
    struct fuse_operations op = {};
    op.getattr = my_getattr;
    op.readdir = my_readdir;
    op.read = my_read;
    op.readlink = my_readlink;
    return fuse_main(argc, argv, &op, nullptr);
}