#!/usr/bin/python
# Copyright (C) 2010, 2011  Lars Wirzenius
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import cliapp
import csv
import json
import os
import sys

import summainlib


class OutputFormat(object):

    keys = ['Mtime', 'Mode', 'Ino', 'Dev', 'Nlink', 'Size',
            'Uid', 'Username', 'Gid', 'Group', 'Target', 'Xattrs']

    def __init__(self, output, checksums, objects):
        self.output = output
        self.checksums = checksums
        self.objects = objects

    def write(self):
        for name, o in self.objects:
            self.write_object(name, o)
        
    def write_object(self, name, o):
        raise NotImplemented()


class Rfc822(OutputFormat):

    def write_object(self, name, o):
        keys = self.keys + self.checksums
        values = [('Name', name)]
        values += [(k, o[k]) for k in keys if o[k] != '']
        record = ''.join('%s: %s\n' % (k, v) for k, v in values if v != '')
        self.output.write('%s\n' % record)


class CSV(OutputFormat):

    def __init__(self, output, checksums, objects):
        OutputFormat.__init__(self, output, checksums, objects)
        self.writer = csv.writer(output)
        self.wrote_headings = False

    def write_object(self, name, o):
        keys = self.keys + self.checksums

        if not self.wrote_headings:
            self.writer.writerow(['Name'] + keys)
            self.wrote_headings = True

        values = [name] + [o[k] or '' for k in keys]
        self.writer.writerow(values)


class GeneratorList(list):

    def __init__(self, gen):
        self.gen = gen
        
    def __len__(self):
        return 1

    def __iter__(self):
        return iter(self.gen)


class Json(OutputFormat):

    def write(self):
        gen = GeneratorList(self.dictify(name, o) for name, o in self.objects)
        json.dump(gen, self.output, sort_keys=True, indent=1)
        self.output.write('\n')

    def dictify(self, name, o):
        keys = self.keys + self.checksums

        values = { 'Name': name }
        for k in keys:
            if o[k] != '':
                values[k] = o[k]

        return values


class Summain(cliapp.Application):

    def add_settings(self):
        self.settings.boolean(['relative-paths', 'r'],
                              'print paths relative to arguments')
        self.settings.boolean(['mangle-paths', 'm'],
                              'mangle (obfuscate) paths')
        self.settings.string(['secret'], 
                             'use SECRET to make mangled paths unguessable')
        self.settings.string_list(['exclude'],
                              'do not output or compute FIELD',
                              metavar='FIELD')
        self.settings.string_list(['checksum', 'c'],
                                  'which checksums to compute: '
                                  'MD5, SHA1, SHA224, SHA256, SHA384, SHA512; '
                                  'use once per checksum type '
                                  '(default is SHA1)')
        self.settings.choice(['output-format', 'f'],
                             ['rfc822', 'csv', 'json'],
                             'choose output format (rfc822, csv, json)')

    def files(self, root):
        if os.path.isdir(root) and not os.path.islink(root):
            for dirname, dirnames, filenames in os.walk(root):
                yield dirname
                dirnames.sort()
                for filename in sorted(filenames):
                    yield os.path.join(dirname, filename)
        elif os.path.islink(root):
            yield root
        elif not os.path.exists(root):
            raise cliapp.AppException('Does not exist: %s' % root)
        else:
            yield root

    def process_args(self, args):
        checksums = [x.upper() 
                     for x in self.settings['checksum'] or ['SHA1']]
        fmt = self.new_formatter(checksums, self.find_roots(args))
        fmt.write()

    def find_roots(self, roots):
        relative = self.settings['relative-paths']
        exclude = self.settings['exclude']
        nn = summainlib.NumberNormalizer()
        if self.settings['mangle-paths']:
            pn = summainlib.PathNormalizer(self.settings['secret'])
        else:
            pn = summainlib.SamePath()

        for root in roots:
            for filename in self.files(root):
                o = summainlib.FilesystemObject(filename, nn, pn, exclude)
                if relative:
                    o.relative = self.relative_path(root, o)
                yield o['Name'], o

    def relative_path(self, root, o):
        '''Return a path that is relative to root, if possible.
        
        If pathname does not start with root, then return it
        unmodified.
        
        '''
        
        if root.endswith(os.sep):
            root2 = root
        else:
            root2 = root + os.sep
        if o.filename.startswith(root2):
            return o.filename[len(root2):]
        elif o.filename == root and o.isdir():
            return '.'
        else:
            return o.filename

    def new_formatter(self, checksums, objects):
        table = {
            'rfc822': Rfc822,
            'csv': CSV,
            'json': Json,
        }
        return table[self.settings['output-format']](self.output, checksums,
                                                      objects)


Summain(version=summainlib.__version__).run()
