"""
manage Mozilla/Firefox profiles
"""

import os
import shutil
from utils import format_tabular
from ConfigParser import SafeConfigParser as ConfigParser

class ProfileNotFound(Exception):
    """
    exception when a profile is specified but is not present in a given
    .ini file
    """

class ProfileManager(object):

    def __init__(self, profiles):
        """
        - profiles: filesystem path to profiles.ini file
        """
        self.profiles = profiles
        self.profile_dir = os.path.abspath(os.path.dirname(profiles))

    ### (public) API

    def list(self, directories=False):
        """
        lists the profiles available in the config file
        - directories : display the directories
        """
        parser = ConfigParser()
        parser.read(self.profiles)
        retval = []
        for section in parser.sections():
            if section == 'General':
                continue
            name = parser.get(section, 'name')
            values = [name]
            if directories:
                values.append(self.path(name))
            retval.append(values)
        return format_tabular(retval)

    def clone(self, source, dest):
        """
        clones the profile `source` and output to `dest`
        """
        source_path = self.path(source)    # fs path of the `from` profile

        dest_path = self.path(dest)  # fs path to back up to
        # TODO:  prepend a hash key

        shutil.copytree(source_path, dest_path, symlinks=False)

        # update profiles.ini
        # TODO


    def backup(self, profile, dest=None):
        """
        backup the profile
        - profile: name of the profile to be backed up
        - dest: name of the destination (optional)
        """
        # XXX should use `self.clone` !
        if dest is None:
            dest = ''
        self.clone(profile, dest)
        # TODO: add something like
        # `Backup=$(profile)s.$(datestamp)s.bak`
        # to self.profiles

    def restore(self, profile, date=None, delete=False):
        """
        restore the profile from a backup
        the most recent backup is used unless `date` is given
        - date : date to restore from
        - delete : delete the backup after restoration
        """
        if delete:
            # delete the backup
            pass

    def merge(self, output, *profiles):
        """merge a set of profiles (not trivial!)"""
        raise NotImplementedError

    ### internal functions

    def path(self, profile):
        """returns the path to the profile"""
        profile = self.profile_dict(profile)
        if profile.get('isrelative', None) == '1':
            return os.path.join(self.profile_dir, profile['path'])
        return profile['path']

    def profile_dict(self, profile):
        parser = ConfigParser()
        parser.read(self.profiles)
        for section in parser.sections():
            if not parser.has_option(section, 'name'):
                continue # not a profile
            if parser.get(section, 'name') == profile:
                return dict(parser.items(section))
        raise ProfileNotFound('Profile %s not found in %s' % (profile, self.profiles))