/*
 *  profuse_xattr.cpp
 *  profuse
 *
 *  Created by Kelvin Sherlock on 1/23/2009.
 *
 */


#include "profuse.h"

#include <algorithm>
#include <string>

#include <cerrno>
#include <cstring>
#include <cstdio>

#include <strings.h>

using std::string;


#ifdef __APPLE__ 
#define NO_ATTRIBUTE ENOATTR
#else
#define NO_ATTRIBUTE EOPNOTSUPP 
#endif

static bool isTextFile(unsigned ftype, unsigned auxtype)
{
    if (ftype == 0x04) return true; // ascii text
    if (ftype == 0xb0) return true; // source code.
    if (ftype == 0x50 && auxtype == 0x5445) return true; // teach text

    return false;
}


static const char *mimeType(unsigned ftype, unsigned auxtype)
{
  switch(ftype)
  {
  case 0x04:
    if (auxtype == 0) return "text/plain";
    break;
  case 0xb0:
    return "text/plain";
    break;
  case 0x50:
    if (auxtype == 0x5445) return "text/plain";
    break;
  case 0xc0:
    if (auxtype == 0x8006) return "image/gif";
    break;
  case 0xe0:
    if (auxtype == 0x8000) return "application/x-BinaryII";
    if (auxtype == 0x8002) return "application/x-Shrinkit";
    break;
  }
  return NULL;
}


static void setCreator(uint8_t *finfo, unsigned ftype, unsigned auxtype)
{
    
    /*
     
     tech note PT515
     ProDOS -> Macintosh conversion
     
     ProDOS             Macintosh
     Filetype    Auxtype    Creator    Filetype
     $00          $0000     'pdos'     'BINA'
     $B0 (SRC)    (any)     'pdos'     'TEXT'
     $04 (TXT)    $0000     'pdos'     'TEXT'
     $FF (SYS)    (any)     'pdos'     'PSYS'
     $B3 (S16)    (any)     'pdos'     'PS16'
     $uv          $wxyz     'pdos'     'p' $uv $wx $yz
     
     Programmer's Reference for System 6.0:
     
     ProDOS Macintosh 
     File Type Auxiliary Type Creator Type File Type 
     $00        $0000           “pdos”  “BINA” 
     $04 (TXT)  $0000           “pdos”  “TEXT” 
     $FF (SYS)  (any)           “pdos”  “PSYS” 
     $B3 (S16)  $DByz           “pdos”  “p” $B3 $DB $yz 
     $B3 (S16)  (any)           “pdos”  “PS16” 
     $D7        $0000           “pdos”  “MIDI” 
     $D8        $0000           “pdos”  “AIFF” 
     $D8        $0001           “pdos”  “AIFC” 
     $E0        $0005           “dCpy”  “dImg” 
     $FF (SYS)  (any)           “pdos”  “PSYS” 
     $uv        $wxyz           “pdos”  “p” $uv $wx $yz 
     
     
     
     */
    
    finfo[0] = 'p';
    finfo[1] = ftype;
    finfo[2] = auxtype >> 8;
    finfo[3] = auxtype;
    
    memcpy(finfo + 4, "pdos", 4);
    
    switch (ftype)
    {
        case 0x00:
            if (auxtype == 0) memcpy(finfo, "BINA", 4);
            break;
            
        case 0x04:
            if (auxtype == 0) memcpy(finfo, "TEXT", 4);
            break;
            
        case 0x50:
            if (auxtype == 0x5445) memcpy(finfo, "TEXT", 4);
            break;
            
        case 0xb0:
            memcpy(finfo, "TEXT", 4);
            break;
            
        case 0xb3:
            if ((auxtype >> 8) != 0xdb) memcpy(finfo, "PS16", 4);
            break;
            
        case 0xd7:
            if (auxtype == 0) memcpy(finfo, "MIDI", 4);
            break;
            
        case 0xd8:
            if (auxtype == 0) memcpy(finfo, "AIFF", 4);
            if (auxtype == 1) memcpy(finfo, "AIFC", 4);
            break;
            
        case 0xe0:
            if (auxtype == 5) memcpy(finfo, "dImgdCpy", 8);
            break;
            
        case 0xff:
            memcpy(finfo, "PSYS", 4);
            break;        
    }
}


#pragma mark XAttribute Functions


static void xattr_filetype(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
    uint8_t attr = e.file_type;
    unsigned attr_size = 1;
    
    if (size == 0)
    {
        fuse_reply_xattr(req, attr_size);
        return;
    }
    
    ERROR (size < attr_size, ERANGE)
    
    // consider position here?
    fuse_reply_buf(req, (char *)&attr, attr_size);    
}


static void xattr_auxtype(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
    uint8_t attr[2];
    unsigned attr_size = 2;
    
    attr[0] = e.aux_type & 0xff;
    attr[1] = (e.aux_type >> 8) & 0xff;
    
    if (size == 0)
    {
        fuse_reply_xattr(req, attr_size);
        return;
    }
    
    ERROR (size < attr_size, ERANGE)
    
    // consider position here?
    fuse_reply_buf(req, (char *)&attr, attr_size);    
}

// user.charset
static void xattr_charset(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
  const char attr[] = "macintosh";
  unsigned attr_size = sizeof(attr) - 1;

  ERROR(!isTextFile(e.file_type, e.aux_type), NO_ATTRIBUTE)

  if (size == 0)
  {
    fuse_reply_xattr(req, attr_size);
    return;
  }

  ERROR (size < attr_size, ERANGE)

  fuse_reply_buf(req, (char *)&attr, attr_size);    
}

//apple.TextEncoding
static void xattr_textencoding(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
  const char attr[] = "MACINTOSH;0";
  unsigned attr_size = sizeof(attr) - 1;

  ERROR(!isTextFile(e.file_type, e.aux_type), NO_ATTRIBUTE)

  if (size == 0)
  {
    fuse_reply_xattr(req, attr_size);
    return;
  }

  ERROR (size < attr_size, ERANGE)

  fuse_reply_buf(req, (char *)&attr, attr_size);
}

static void xattr_rfork(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
    int ok;
    unsigned level;
    
    ERROR (e.storage_type != EXTENDED_FILE, NO_ATTRIBUTE)
    
    ok = disk->Normalize(e, 1);
    ERROR(ok < 0, EIO)
    
    
    switch(e.storage_type)
    {
        case SEEDLING_FILE:
            level = 0;
            break;
        case SAPLING_FILE:
            level = 1;
            break;
        case TREE_FILE:
            level = 2;
            break;
        default:
            ERROR(true, EIO)
    }
    
    if (size == 0)
    {
        fuse_reply_xattr(req, e.eof);
        return;
    }
    
    size = std::min((uint32_t)(size + off), e.eof);
    
    unsigned blocks = (size + (off & 0x1ff) + BLOCK_SIZE - 1) >> 9;
    uint8_t *buffer = new uint8_t[blocks << 9];
    
    fprintf(stderr, "ReadIndex(%x, buffer, %x, %x, %x)\n", e.key_pointer, level, (int)off, (int)blocks);
    
    ok = disk->ReadIndex(e.key_pointer, buffer, level, off, blocks);
    
    if (ok < 0)
    {
        fuse_reply_err(req, EIO);
    }
    else
    {
        fuse_reply_buf(req, (char *)buffer + (off & 0x1ff), size);
    }
    delete []buffer;
    return;
}



// Finder info.
static void xattr_finfo(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
    int ok;
    ExtendedEntry ee;
    
    uint8_t attr[32];
    unsigned attr_size = 32;
    
    //ERROR (e.storage_type != EXTENDED_FILE, ENOENT)
    
    switch (e.storage_type)
    {
        case SEEDLING_FILE:
        case SAPLING_FILE:
        case TREE_FILE:
        
            if (size == 0)
            {
                fuse_reply_xattr(req, attr_size);
                return;
            }
        
            bzero(attr, attr_size);
            setCreator(attr, e.file_type, e.aux_type);
            fuse_reply_buf(req, (char *)attr, attr_size);
            return;
        
        case EXTENDED_FILE:
            // handled below.
            break;

        default:
            ERROR(true, NO_ATTRIBUTE);
    }
    
    
    ok = disk->Normalize(e, 1, &ee);
    ERROR(ok < 0, EIO)
    
    // sanity check
    switch(e.storage_type)
    {
        case SEEDLING_FILE:
        case SAPLING_FILE:
        case TREE_FILE:
            break;
        default:
            ERROR(true, EIO)
    }
    
    if (size == 0)
    {
        fuse_reply_xattr(req, attr_size);
        return;
    }
    
    ERROR (size < attr_size, ERANGE)
    
    memcpy(attr, ee.FInfo, 16);
    memcpy(attr + 16, ee.xFInfo, 16);

    // if no creator, create one.
    if (memcmp(attr, "\0\0\0\0\0\0\0\0", 8) == 0)
        setCreator(attr, e.file_type, e.aux_type);
    
    fuse_reply_buf(req, (char *)attr, attr_size);
}


static void xattr_mimetype(FileEntry& e, fuse_req_t req, size_t size, off_t off)
{
  unsigned attr_size;
  const char *mime = mimeType(e.file_type, e.aux_type);
  ERROR(!mime, NO_ATTRIBUTE);

  attr_size = strlen(mime);

  if (size == 0)
  {
    fuse_reply_xattr(req, attr_size);
    return;
  }

  ERROR (size < attr_size, ERANGE)

  fuse_reply_buf(req, mime, attr_size);
}



void prodos_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
{
    // list of supported attributes.
    //
#define NO_ATTR() \
{ \
if (size) fuse_reply_buf(req, NULL, 0); \
else fuse_reply_xattr(req, 0); \
return; \
}
    
    fprintf(stderr, "listxattr %u\n", (unsigned)ino);
    
    uint8_t buffer[BLOCK_SIZE];
    int ok;
    unsigned attr_size;
    string attr;
    
    
    
    if(ino == 1)
        NO_ATTR()
        
        ok = disk->Read(ino >> 9, buffer);
    
    ERROR(ok < 0, EIO)
    
    
    FileEntry e;
    e.Load(buffer + (ino & 0x1ff));
    
    
    attr += "prodos.FileType";
    attr.append(1, 0);
    
    attr += "prodos.AuxType";
    attr.append(1, 0);
    
    switch(e.storage_type)
    {
        case EXTENDED_FILE:
        {
            // TODO -- pretend there's no resource fork if resource fork eof == 0 ?
            //
            //ok = disk->Normalize(e, 1);            
            //ERROR(ok < 0, EIO)
            
            attr += "prodos.ResourceFork"; 
            attr.append(1, 0);
            
            attr += "com.apple.FinderInfo";
            attr.append(1, 0);
            break;
        }
            
        case SEEDLING_FILE:
        case SAPLING_FILE:
        case TREE_FILE:
            // generate HFS creator codes.
            attr += "com.apple.FinderInfo";
            attr.append(1, 0);
            break;
            
        case DIRECTORY_FILE:
            NO_ATTR()
            break;
            
        default:
            
            NO_ATTR()
            break;
    }
    
    if (isTextFile(e.file_type, e.aux_type))
    {
        attr += "com.apple.TextEncoding";
        attr.append(1, 0);

        attr += "user.charset";
        attr.append(1, 0);
    }

    if (mimeType(e.file_type, e.aux_type))
    { 
        attr += "user.mime_type";
        attr.append(1, 0);
    }
    
    attr_size = attr.length();
    
    fprintf(stderr, "%d %s\n", attr_size, attr.c_str());
    
    if (size == 0)
    {
        fuse_reply_xattr(req, attr_size);
        return;
    }
    
    if (size < attr_size)
    {
        fuse_reply_err(req, ERANGE);
        return;
    }
    
    fuse_reply_buf(req, attr.data(), attr_size);
    return;
}

/*
 * offset is only valid in OS X for the resource fork.
 *
 */
void prodos_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name, size_t size, uint32_t off)
{

    
    fprintf(stderr, "getxattr: %u %s %u %u \n", (unsigned)ino, name, (unsigned)size, (unsigned)off);
    
    uint8_t buffer[BLOCK_SIZE];
    
    
    ERROR(ino == 1, NO_ATTRIBUTE) // finder can't handle EISDIR.
    
    
    int ok = disk->Read(ino >> 9, buffer);
    
    ERROR(ok < 0, EIO)
    
    
    FileEntry e;
    e.Load(buffer + (ino & 0x1ff));
    
    switch(e.storage_type)
    {
        case SEEDLING_FILE:
        case SAPLING_FILE:
        case TREE_FILE:
        case EXTENDED_FILE:
            break;
        case DIRECTORY_FILE:
            ERROR(true, NO_ATTRIBUTE) // Finder can't handle EISDIR.
        default:
            ERROR(true, NO_ATTRIBUTE);
    }
    
    if (strcmp("prodos.FileType", name) == 0)
    {
        xattr_filetype(e, req, size, off);
        return;
    }
    
    if (strcmp("prodos.AuxType", name) == 0)
    {
        xattr_auxtype(e, req, size, off);
        return;
    }
    
    if (strcmp("com.apple.TextEncoding", name) == 0)
    {
        xattr_textencoding(e, req, size, off);
        return;        
    }
    
    if ( (e.storage_type == EXTENDED_FILE) && (strcmp("prodos.ResourceFork", name) == 0))   
    {
        xattr_rfork(e, req, size, off);
        return;          
    }
    
    if ( strcmp("com.apple.FinderInfo", name) == 0)   
    {
        xattr_finfo(e, req, size, off);
        return;          
    }
   
    // linux standard
    if (strcmp("user.mime_type", name) == 0)
    {
      xattr_mimetype(e, req, size, off);
      return;
    } 

    // linux standard
    if (strcmp("user.charset", name) == 0)
    {
      xattr_charset(e, req, size, off);
      return;
    }
    
    fuse_reply_err(req, NO_ATTRIBUTE);
    
}
/*
 * Linux, et alia do not have an offset parameter.
 */
void prodos_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name, size_t size)
{
    prodos_getxattr(req, ino, name, size, 0);
}