// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2009 Brad Schick <schickb@gmail.com>

 *

 * This file is part of the organize tool.

 *

 * 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 2

 * 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

/*

 File:      helpers.cpp

 Author(s): Brad Schick (brad) <schickb@gmail.com>

 History:   19-Jan-09, brad: created

*/

// *****************************************************************************

#include <boost/algorithm/string.hpp>

#include <boost/regex.hpp>

#include <boost/format.hpp>

#include <boost/lexical_cast.hpp>

#include <exiv2/image.hpp>

#include <exiv2/easyaccess.hpp>

#include <exiv2/exif.hpp>

#include <exiv2/iptc.hpp>

#include <exiv2/tags.hpp>

//#include <exiv2/xmp.hpp>

#include <cassert>

#include <sstream>

#include <ctime>

#include "helpers.hpp"

#define BOOST_FILESYSTEM_NO_DEPRECATED

namespace fs = boost::filesystem;

typedef Exiv2::ExifData::const_iterator (*EasyAccessFct)(const Exiv2::ExifData& ed);

std::string scrub(const std::string &dirty, bool strip_space = false)

{

    std::string scrub = boost::trim_copy(dirty);

    if(strip_space) {

        boost::regex space("\\s");

        scrub = boost::regex_replace(scrub, space, "");

    }

    boost::regex dash("[:/\\\\|<>]");

    boost::regex under("[\"'\\[\\]\\{\\}#=%\\$\\?,\\+\\*]");

    scrub = boost::regex_replace(scrub, dash, "-");

    return boost::regex_replace(scrub, under, "_");

}

bool exif_data(const Exiv2::Image *image, const char *key, Exiv2::ExifData::const_iterator &md) 

{

    assert(image && key);

    bool ok = false;

    try {

        const Exiv2::ExifData &exifData = image->exifData();

        Exiv2::ExifKey exifKey(key);

        md = exifData.findKey(exifKey);

        if(md != exifData.end() && md->typeId() != Exiv2::undefined)

            ok = true;

    } 

    catch(const Exiv2::AnyError&) {

    }

    return ok;

}

bool exif_data_easy(const Exiv2::Image *image, EasyAccessFct easy, Exiv2::ExifData::const_iterator &md) 

{

    assert(image && easy);

    bool ok = false;

    try {

        const Exiv2::ExifData &exifData = image->exifData();

        md = easy(exifData);

        if(md != exifData.end() && md->typeId() != Exiv2::undefined)

            ok = true;

    } 

    catch(const Exiv2::AnyError&) {

    }

    return ok;

}

bool iptc_data(const Exiv2::Image *image, const char *key, Exiv2::IptcData::const_iterator &md) 

{

    bool ok = false;

    assert(image && key);

    try {

        const Exiv2::IptcData &iptcData = image->iptcData();

        Exiv2::IptcKey iptcKey(key);

        md = iptcData.findKey(iptcKey);

        if(md != iptcData.end() && md->typeId() != Exiv2::undefined)

            ok = true;

    } 

    catch(const Exiv2::AnyError&) {

    }

    return ok;

}

std::string exif_date(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.DateTimeDigitized", md);

    if(!done)

        done = exif_data(image, "Exif.Photo.DateTimeOriginal", md);

    if(!done)

        return "";

    std::string date = scrub(md->print().substr(0,10));

    // Some files have zeros for dates, just fail in that case

    if(boost::lexical_cast<int>(date.substr(0,4))==0)

        return "";

    return date;

}

std::string exif_year(const Exiv2::Image *image, const fs::path &path) 

{

    std::string date = exif_date(image, path);

    if(date.length())

        return date.substr(0,4);

    else

        return date;

}

std::string exif_month(const Exiv2::Image *image, const fs::path &path) 

{

    std::string date = exif_date(image, path);

    if(date.length())

        return date.substr(5,2);

    else

        return date;

}

std::string exif_day(const Exiv2::Image *image, const fs::path &path) 

{

    std::string date = exif_date(image, path);

    if(date.length())

        return date.substr(8,2);

    else

        return date;

}

bool iptc_get_date(const Exiv2::Image *image, Exiv2::DateValue::Date &date) 

{

    Exiv2::IptcData::const_iterator md;

    bool done = iptc_data(image, "Iptc.Application2.DigitizationDate", md);

    if(!done)

        done = iptc_data(image, "Iptc.Application2.DateCreated", md);

    if(!done)

        return false;

    date = ((Exiv2::DateValue*)md->getValue().get())->getDate();

    return date.year > 0;

}

std::string iptc_date(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::DateValue::Date date;

    if(iptc_get_date(image, date))

        return str(boost::format("%4d-%02d-%02d") % date.year % date.month % date.day);

    else

        return "";

}

std::string iptc_year(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::DateValue::Date date;

    if(iptc_get_date(image, date))

        return str(boost::format("%4d") % date.year);

    else

        return "";

}

std::string iptc_month(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::DateValue::Date date;

    if(iptc_get_date(image, date))

        return str(boost::format("%02d") % date.month);

    else

        return "";

}

std::string iptc_day(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::DateValue::Date date;

    if(iptc_get_date(image, date))

        return str(boost::format("%02d") % date.day);

    else

        return "";

}

bool file_get_tm(const fs::path &path, std::tm &tm)

{

    std::time_t timer = fs::last_write_time(path);

    if(time > 0) {

        tm = *localtime(&timer;;

        return true;

    } 

    else {

        return false;

    }

}

std::string file_date(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%4d-%02d-%02d") % (tm.tm_year + 1900) % (tm.tm_mon + 1) % tm.tm_mday);

    else

        return "";

}

std::string file_year(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%4d") % (tm.tm_year + 1900));

    else

        return "";

}

std::string file_month(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d") % (tm.tm_mon + 1));

    else

        return "";

}

std::string file_day(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d") % tm.tm_mday);

    else

        return "";

}

/*

std::string xmp_date(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_year(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_month(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_day(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_time(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.DateTimeDigitized", md);

    if(!done)

        done = exif_data(image, "Exif.Photo.DateTimeOriginal", md);

    if(!done)

        return "";

    std::string datetime = md->print();

    // Some files have zeros for dates, just fail in that case

    if(boost::lexical_cast<int>(datetime.substr(0,4)) == 0)

        return "";

    return scrub(datetime.substr(11));

}

std::string exif_hour(const Exiv2::Image *image, const fs::path &path) 

{

    std::string time = exif_time(image, path);

    if(time.length())

        return time.substr(0,2);

    else

        return time;

}

std::string exif_minute(const Exiv2::Image *image, const fs::path &path) 

{

    std::string time = exif_time(image, path);

    if(time.length())

        return time.substr(3,2);

    else

        return time;

}

std::string exif_second(const Exiv2::Image *image, const fs::path &path) 

{

    std::string time = exif_time(image, path);

    if(time.length())

        return time.substr(6,2);

    else

        return time;

}

bool iptc_get_time(const Exiv2::Image *image, Exiv2::TimeValue::Time &time) 

{

    Exiv2::IptcData::const_iterator md;

    bool done = iptc_data(image, "Iptc.Application2.DigitizationTime", md);

    if(!done)

        done = iptc_data(image, "Iptc.Application2.TimeCreated", md);

    if(!done)

        return false;

    time = ((Exiv2::TimeValue*)md->getValue().get())->getTime();

    // Zero is a valid time, so this one is hard to check.

    return true;

}

std::string iptc_time(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::TimeValue::Time time;

    if(iptc_get_time(image, time))

        return str(boost::format("%02d-%02d-%02d") % time.hour % time.minute % time.second);

    else

        return "";

}

std::string iptc_hour(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::TimeValue::Time time;

    if(iptc_get_time(image, time))

        return str(boost::format("%02d") % time.hour);

    else

        return "";

}

std::string iptc_minute(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::TimeValue::Time time;

    if(iptc_get_time(image, time))

        return str(boost::format("%02d") % time.minute);

    else

        return "";

}

std::string iptc_second(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::TimeValue::Time time;

    if(iptc_get_time(image, time))

        return str(boost::format("%02d") % time.second);

    else

        return "";

}

std::string file_time(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d-%02d-%02d") % tm.tm_hour % tm.tm_min % tm.tm_sec);

    else

        return "";

}

std::string file_hour(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d") % tm.tm_hour);

    else

        return "";

}

std::string file_minute(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d") % tm.tm_min);

    else

        return "";

}

std::string file_second(const Exiv2::Image *, const fs::path &path) 

{

    std::tm tm;

    if(file_get_tm(path, tm))

        return str(boost::format("%02d") % tm.tm_sec);

    else

        return "";

}

/*std::string xmp_time(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_hour(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_minute(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_second(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_dimension(const Exiv2::Image *image, const fs::path &path) 

{

    return exif_width(image, path) + "-" + exif_height(image, path);

}

std::string exif_width(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.PixelXDimension", md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string exif_height(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.PixelYDimension", md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string file_dimension(const Exiv2::Image *image, const fs::path &path) 

{

    if(image)

        return file_width(image, path) + "-" + file_height(image, path);

    else

        return "";

}

std::string file_width(const Exiv2::Image *image, const fs::path &) 

{

    if(image)

        return str(boost::format("%02d") % image->pixelWidth());

    else

        return "";

}

std::string file_height(const Exiv2::Image *image, const fs::path &) 

{

    if(image)

        return str(boost::format("%02d") % image->pixelHeight());

    else

        return "";

}

/*

std::string xmp_dimension(const Exiv2::Image *image, const fs::path &) 

{

    return ""

}

std::string xmp_width(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}

std::string xmp_height(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_model(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Image.Model", md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string exif_make(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Image.Make", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_model(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_speed(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.ShutterSpeedValue", md);

    if(!done)

        done = exif_data(image, "Exif.Photo.ExposureTime", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_speed(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_aperture(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.ApertureValue", md);

    if(!done)

        done = exif_data(image, "Exif.Photo.FNumber", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_aperture(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_focal(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.FocalLength", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_focal(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_distance(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.SubjectDistance", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_distance(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_meter(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.MeteringMode", md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string exif_macro(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data_easy(image, Exiv2::macroMode, md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string exif_orientation(const Exiv2::Image *image, const fs::path &)

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data_easy(image, Exiv2::orientation, md);

    if(!done)

        return "";

    return scrub(md->print(), true);

}

std::string exif_lens(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data_easy(image, Exiv2::lensName, md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string exif_iso(const Exiv2::Image *image, const fs::path &)

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data_easy(image, Exiv2::isoSpeed, md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_meter(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/

std::string exif_keyword(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::ExifData::const_iterator md;

    bool done = exif_data(image, "Exif.Photo.UserComment", md);

    if(!done)

        return "";

    return scrub(md->print());

}

std::string iptc_keyword(const Exiv2::Image *image, const fs::path &) 

{

    Exiv2::IptcData::const_iterator md;

    bool done = iptc_data(image, "Iptc.Application2.Keywords", md);

    if(!done)

        return "";

    return scrub(md->print());

}

/*std::string xmp_keyword(const Exiv2::Image *image, const fs::path &) 

{

    return "";

}*/