#!/usr/bin/env python

import logging

from collections import defaultdict
from errno import ENOENT
from stat import S_IFDIR, S_IFLNK, S_IFREG
from sys import argv, exit
from time import time
from datetime import datetime, timedelta
from fuse import FUSE, FuseOSError, Operations, LoggingMixIn
#sudo pip install lxml
from lxml import etree

import collections
import re

if not hasattr(__builtins__, 'bytes'):
    bytes = str

class Memory(LoggingMixIn, Operations):
    'Example memory filesystem. Supports only one level of files.'

    def set_attr(self,node,attr,value):
        node.attrib[attr]=repr(value)

    def get_attr(self,node,attr):
        if(attr=='st_ctime') or (attr=='st_mtime' ) or (attr=='st_atime'):
            return float(node.attrib[attr])
        else:
            return int(node.attrib[attr])

    def get_node(self,path):
        logger.debug('fs'+path)
        return self.root.find('fs'+path)

    def get_node_name(self,path):
        a= ('fs'+path).split('/')
        logger.debug(a)
        return a.pop(-1)

    def get_node_parent(self,path):
        a= ('fs'+path).split('/')
        logger.debug(a)
        a.pop(-1)
        logger.debug('----'+'/'.join(a))
        return self.root.find('/'.join(a))

    def __init__(self):
        self.files = {}
        self.root = etree.Element("root")
        self.data = defaultdict(bytes)
        self.fd = 0
        now = time()
        self.files['/'] = dict( st_mode=(S_IFDIR | 0755),
                                st_ctime=now,
                                st_mtime=now,
                                st_atime=now,
                                st_nlink=2)
        fs = etree.SubElement(self.root,'fs')
        self.set_attr(fs,'st_mode' ,S_IFDIR | 0755)
        self.set_attr(fs,'st_ctime',now)
        self.set_attr(fs,'st_mtime',now)
        self.set_attr(fs,'st_atime',now)
        self.set_attr(fs,'st_nlink',2)

    def chmod(self, path, mode):
        self.files[path]['st_mode'] &= 0770000
        self.files[path]['st_mode'] |= mode
        node = self.get_node(path)
        val = self.get_attr(node,'st_mode')
        val &= 0770000
        val |= mode
        self.set_attr(node,'st_mode',val)
        return 0

    def chown(self, path, uid, gid):
        self.files[path]['st_uid'] = uid
        self.files[path]['st_gid'] = gid
        node = self.get_node(path)
        self.set_attr(node,'st_uid',uid)
        self.set_attr(node,'st_gid',gid)

    def getattr(self, path, fh=None):
        if path not in self.files:
            raise FuseOSError(ENOENT)

        return self.files[path]

    def create(self, path, mode):
        logger.info("####"+path)
        logger.info('parent '+self.get_node_parent(path).tag)
        logger.info('name '+self.get_node_name(path))

        #m = re.search('--([0-9]*)$', path)
        #if (m):
        #    self.expires[path]=datetime.now() + timedelta(seconds=int(m.group(1)))
        #    logger.info("####"+path+" ")
        #    repr(self.expires[path])
        #    logger.info("####"+path+" ")
        self.files[path] = dict(st_mode=(S_IFREG | mode), st_nlink=1,
                                st_size=0, st_ctime=time(), st_mtime=time(),
                                st_atime=time())

        self.fd += 1
        node = etree.SubElement(self.get_node_parent(path),self.get_node_name(path))
        self.set_attr(node,'st_mode' ,S_IFREG | mode)
        self.set_attr(node,'st_size' ,0)
        self.set_attr(node,'st_ctime',time())
        self.set_attr(node,'st_mtime',time())
        self.set_attr(node,'st_atime',time())
        self.set_attr(node,'st_nlink',1)
        logger.debug(etree.tostring(self.root, pretty_print=True))
        return self.fd

    def readdir(self, path, fh):
        return ['.', '..'] + [x[1:] for x in self.files if x != '/']

    def rmdir(self, path):
        self.files.pop(path)
        self.files['/']['st_nlink'] -= 1

    def mkdir(self, path, mode):
        self.files[path] = dict(st_mode=(S_IFDIR | mode), st_nlink=2,
                                st_size=0, st_ctime=time(), st_mtime=time(),
                                st_atime=time())

        self.files['/']['st_nlink'] += 1
        self.set_attr(self.get_node_parent(path),'st_nlink',self.get_attr(self.get_node_parent(path),'st_nlink')+1)
        node = etree.SubElement(self.get_node_parent(path),self.get_node_name(path))
        self.set_attr(node,'st_ctime',time())
        self.set_attr(node,'st_mtime',time())
        self.set_attr(node,'st_atime',time())
        self.set_attr(node,'st_mode' ,S_IFDIR | mode)
        self.set_attr(node,'st_size' ,0)
        self.set_attr(node,'st_nlink',2)
        logger.debug(etree.tostring(self.root, pretty_print=True))

    def open(self, path, flags):
        self.fd += 1
        return self.fd

    def rename(self, old, new):
        self.files[new] = self.files.pop(old)

    def statfs(self, path):
        return dict(f_bsize=512, f_blocks=4096, f_bavail=2048)

    def utimens(self, path, times=None):
        now = time()
        atime, mtime = times if times else (now, now)
        self.files[path]['st_atime'] = atime
        self.files[path]['st_mtime'] = mtime


    def symlink(self, target, source):
        self.files[target] = dict(st_mode=(S_IFLNK | 0777), st_nlink=1,
                                  st_size=len(source))
        self.data[target] = source

    def readlink(self, path):
        return self.data[path]

    def unlink(self, path):
        self.files.pop(path)


    def truncate(self, path, length, fh=None):
        self.data[path] = self.data[path][:length]
        self.files[path]['st_size'] = length

    def read(self, path, size, offset, fh):
        return self.data[path][offset:offset + size]

    def write(self, path, data, offset, fh):
        self.data[path] = self.data[path][:offset] + data
        self.files[path]['st_size'] = len(self.data[path])
        return len(data)


    def getxattr(self, path, name, position=0):
        attrs = self.files[path].get('attrs', {})

        try:
            return attrs[name]
        except KeyError:
            return ''       # Should return ENOATTR

    def listxattr(self, path):
        attrs = self.files[path].get('attrs', {})
        return attrs.keys()

    def removexattr(self, path, name):
        attrs = self.files[path].get('attrs', {})

        try:
            del attrs[name]
        except KeyError:
            pass        # Should return ENOATTR

    def setxattr(self, path, name, value, options, position=0):
        # Ignore options
        attrs = self.files[path].setdefault('attrs', {})
        attrs[name] = value



if __name__ == '__main__':
    if len(argv) != 2:
        print('usage: %s <mountpoint>' % argv[0])
        exit(1)

    logging.getLogger().setLevel(logging.DEBUG)
    logging.basicConfig()
    logger = logging.getLogger()
    fuse = FUSE(Memory(), argv[1], foreground=True)