#!/usr/bin/python

# ExiFilm -- Add film exposure metadata to EXIF tags of digital images
# Copyright (C) 2009 James E. Blair <corvus@gnu.org>
#
# 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 pygtk
pygtk.require('2.0')
import gtk, gobject
import gtk.glade
import gtk.keysyms
from gtk import gdk

import os, sys
import pyexiv2
import datetime
import decimal, fractions
import re

HALF_STOP_SCALE = ['1', '1.2', '1.4', '1.7', '2', '2.4', '2.8', '3.3', '4', '4.8',
                   '5.6', '6.7', '8', '9.5', '11', '13', '16', '19', '22', '27',
                   '32', '38', '45', '54', '64', '76', '91']


THIRD_STOP_SCALE = ['1', '1.1', '1.2', '1.4', '1.6', '1.8', '2', '2.2', '2.5',
                    '2.8', '3.2', '3.5', '4', '4.5', '5.0', '5.6', '6.3', '7.1',
                    '8', '9', '10', '11', '13', '14', '16', '18', '20', '22',
                    '25', '29', '32', '36', '40', '45', '51', '57', '64', '72',
                    '81', '91']

CAMERA_MOVEMENTS = [
    'rising',
    'falling',
    'forward tilt',
    'backward tilt',
    'left shift',
    'right shift',
    'left swing',
    'right swing',
    ]

ID = 'ID'
FILM = 'Film'
CARRIER = 'Carrier'
PROCESS = 'Process'
FRONT_MOVEMENTS = 'Front movements'
REAR_MOVEMENTS = 'Rear movements'

PRIVATE_KEYS = [
    ID,
    FILM,
    CARRIER,
    PROCESS,
    FRONT_MOVEMENTS,
    REAR_MOVEMENTS,
    ]

ISO_RE = re.compile(r'\d\d+')

def to_rational(v):
    if '/' in v:
        n,d = v.split('/')
    else:
        n,d = (v,1)
    return pyexiv2.Rational(int(n), int(d))

def from_rational(v):
    if not v: return v
    n,d = str(v).split('/')
    if d == '1':
        return str(n)
    return str(v)

def from_fstop(v):
    if '/' in v:
        whole, frac = v.split(' ')
        n,d = frac.split('/')
        if d == '2': scale = HALF_STOP_SCALE
        if d == '3': scale = THIRD_STOP_SCALE
        i = scale.index(whole)
        i += int(n)
        f = fractions.Fraction.from_decimal(decimal.Decimal(str(scale[i])))
        return str(f)
    f = fractions.Fraction.from_decimal(decimal.Decimal(v))
    return str(f)

def to_fstop(v):
    if '/' in v:
        n,d = v.split('/')
        return str(float(n)/float(d))
    return v

def encode_comments(d, comments):
    ret = ''
    for k in PRIVATE_KEYS:
        if k in d.keys():
            ret += '%s: %s\n' % (k, d[k])
    ret += '\n'+comments
    return ret

def decode_comments(comments):
    d = {}
    ret = ''
    lines = comments.split('\n')
    while lines:
        line = lines.pop(0).strip()
        if not line: break
        if ':' in line:
            k,v = line.split(':', 1)
            d[k.strip()] = v.strip()
        else:
            ret += line+'\n'
            break
    return d, ret+'\n'.join(lines)

class ExiFilm(object):

    def __init__(self):
        self.image = None
        self.xml = gtk.glade.XML('exifilm.glade', 'main_window')

        self.file_combo = self.xml.get_widget('file')

        self.id_entry = self.xml.get_widget('id')
        self.film_entry = self.xml.get_widget('film')
        self.carrier_entry = self.xml.get_widget('carrier')
        self.process_entry = self.xml.get_widget('process')
        self.lens_entry = self.xml.get_widget('lens')
        self.aperture_entry = self.xml.get_widget('aperture')
        self.shutter_entry = self.xml.get_widget('shutter')

        self.front_button = self.xml.get_widget('front')
        self.rear_button = self.xml.get_widget('rear')

        self.description_entry = self.xml.get_widget('description')
        self.date_button = self.xml.get_widget('date')

        self.comments_text = self.xml.get_widget('comments')
        self.comments_buffer = gtk.TextBuffer()
        self.comments_text.set_buffer(self.comments_buffer)

        # Keep the last selected date to provide a sane default
        self.lastdate = None

        dic = {
            'on_main_window_destroy': self.window_closed,
            'on_main_window_key_press_event': self.key_press,
            'on_date_clicked': self.date_clicked,
            'on_front_clicked': self.front_clicked,
            'on_rear_clicked': self.rear_clicked,
            'on_file_changed': self.file_changed,
            }

        self.xml.signal_autoconnect (dic)

        self.file_store = gtk.ListStore(gobject.TYPE_STRING)
        cell = gtk.CellRendererText()
        self.file_combo.pack_start(cell, True)
        self.file_combo.add_attribute(cell, 'text', 0)
        self.file_combo.set_model(self.file_store)

        self.filename = None
        first = None
        self.directory = '.'
        if len(sys.argv)>1:
            self.directory = sys.argv[1]
        files = os.listdir(self.directory)
        files.sort()
        for fn in files:
            if not (fn.lower().endswith('.jpeg') or
                    fn.lower().endswith('.jpg')):
                continue
            if not first: first = fn
            self.file_store.append((fn,))
        if first:
            self.file_combo.set_active(0)

    def file_changed(self, widget, data=None):
        if self.filename:
            self.save()
        i = self.file_combo.get_active()
        fn = self.file_store[i][0]
        self.load(fn)
        self.id_entry.grab_focus()

    def key_press(self, widget, data=None):
        if data.keyval == gtk.keysyms.Page_Up:
            i = self.file_combo.get_active()
            if i>0:
                self.file_combo.set_active(i-1)
            return True

        if data.keyval == gtk.keysyms.Page_Down:
            i = self.file_combo.get_active()
            if i<len(self.file_store)-1:
                self.file_combo.set_active(i+1)
            return True

    def load(self, fn):
        fn = os.path.join(self.directory, fn)
        self.filename = fn

        image = pyexiv2.ImageMetadata(fn)
        image.read()
        keys = image.exif_keys
        self.image = image

        def get(key, default=''):
            if key in keys:
                return image[key].value
            return default

        self.date = get('Exif.Photo.DateTimeOriginal', None)
        if self.date:
            self.date_button.set_label(str(self.date.date()))
        else:
            self.date_button.set_label('Set')

        self.shutter_entry.set_text(str(get('Exif.Photo.ExposureTime')))
        self.aperture_entry.set_text(to_fstop(str(get('Exif.Photo.FNumber'))))
        self.lens_entry.set_text(str(get('Exif.Photo.FocalLength')))

        self.description_entry.set_text(get('Exif.Image.ImageDescription'))
        extras, comments = decode_comments(get('Exif.Photo.UserComment'))
        self.comments_buffer.set_text(comments)

        self.id_entry.set_text(extras.get(ID, ''))
        self.film_entry.set_text(extras.get(FILM, ''))
        self.carrier_entry.set_text(extras.get(CARRIER, ''))
        self.process_entry.set_text(extras.get(PROCESS, ''))

        self.front_movements = extras.get(FRONT_MOVEMENTS, '')
        if self.front_movements:
            self.front_button.set_label(self.front_movements)
        else:
            self.front_button.set_label('None')

        self.rear_movements = extras.get(REAR_MOVEMENTS, '')
        if self.rear_movements:
            self.rear_button.set_label(self.rear_movements)
        else:
            self.rear_button.set_label('None')

    def save(self):
        if self.date:
            self.image['Exif.Photo.DateTimeOriginal'] = self.date
        v = self.shutter_entry.get_text()
        if v: self.image['Exif.Photo.ExposureTime'] = to_rational(v)
        v = self.aperture_entry.get_text()
        if v: self.image['Exif.Photo.FNumber'] = to_rational(from_fstop(v))
        v = self.lens_entry.get_text()
        if v: self.image['Exif.Photo.FocalLength'] = to_rational(v)
        v = self.description_entry.get_text()
        if v: self.image['Exif.Image.ImageDescription'] = v

        extras = {}

        v = self.id_entry.get_text()
        if v: extras[ID] = v
        v = self.film_entry.get_text()
        if v:
            extras[FILM] = v
            m = ISO_RE.search(v)
            if m:
                iso = int(m.group(0))
                self.image['Exif.Photo.ISOSpeedRatings'] = iso
        v = self.carrier_entry.get_text()
        if v: extras[CARRIER] = v
        v = self.process_entry.get_text()
        if v: extras[PROCESS] = v
        if self.front_movements:
            extras[FRONT_MOVEMENTS] = self.front_movements
        if self.rear_movements:
            extras[REAR_MOVEMENTS] = self.rear_movements

        bounds = self.comments_buffer.get_bounds()
        v = self.comments_buffer.get_text(bounds[0], bounds[1])
        if v or extras:
            self.image['Exif.Photo.UserComment'] = encode_comments(extras, v)

        self.image.write()

    def window_closed(self, widget, data=None):
        if self.image:
            self.save()
        gtk.main_quit()

    def date_clicked(self, widget, data=None):
        xml = gtk.glade.XML('exifilm.glade', 'calendar_dialog')
        calendar_dialog = xml.get_widget('calendar_dialog')
        calendar = xml.get_widget('calendar')
        if self.date:
            date = self.date
        else:
            if self.lastdate:
                date = self.lastdate
            else:
                date = datetime.datetime.now()
        calendar.select_month(date.month-1, date.year)
        calendar.select_day(date.day)
        r = calendar_dialog.run()
        if r:
            date = calendar.get_date()
            self.date = datetime.datetime(date[0], date[1]+1, date[2])
            self.lastdate = self.date
            self.date_button.set_label(str(self.date.date()))
        calendar_dialog.destroy()

    def front_clicked(self, widget, data=None):
        moves = self.front_movements.split('/')
        moves = self.get_movements(moves)
        self.front_movements = '/'.join(moves)
        if self.front_movements:
            self.front_button.set_label(self.front_movements)
        else:
            self.front_button.set_label('None')

    def rear_clicked(self, widget, data=None):
        moves = self.rear_movements.split('/')
        moves = self.get_movements(moves)
        self.rear_movements = '/'.join(moves)
        if self.rear_movements:
            self.rear_button.set_label(self.rear_movements)
        else:
            self.rear_button.set_label('None')

    def get_movements(self, orig_movements):
        xml = gtk.glade.XML('exifilm.glade', 'movement_dialog')
        dialog = xml.get_widget('movement_dialog')
        tree_view = xml.get_widget('movements')

        column = gtk.TreeViewColumn("Movements")
        renderer=gtk.CellRendererText()
        column.pack_start(renderer,0)
        column.add_attribute(renderer, 'text', 0)
        tree_view.append_column(column)

        tree_store = gtk.TreeStore(str)
        tree_view.set_model(tree_store)
        tree_view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
        for i,m in enumerate(CAMERA_MOVEMENTS):
            tree_store.append(None, (m,))
            if m in orig_movements:
                tree_view.get_selection().select_path((i,))

        r = dialog.run()
        if r:
            store, rows = tree_view.get_selection().get_selected_rows()
            ret = []
            for row in rows:
                ret.append(tree_store.get_value(tree_store.get_iter(row), 0))
        else:
            ret = orig_movements
        dialog.destroy()
        return ret

def main():
    gdk.threads_init()
    gdk.threads_enter()
    ExiFilm()
    gtk.main()
    gdk.threads_leave()

if __name__=='__main__':
    if len(sys.argv)>1 and sys.argv[1][0]=='-':
        print "Usage: %s [PATH]" % sys.argv[0]
        print
        print "  PATH is a directory with JPEG files to edit."
        print "  PATH defaults to the current directory."
    else:
        main()