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

/*

 * Copyright (C) 2004-2018 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

 * 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:      actions.cpp

 */

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

// included header files

#include "config.h"

#include "actions.hpp"

#include "exiv2app.hpp"

#include "image.hpp"

#include "jpgimage.hpp"

#include "xmpsidecar.hpp"

#include "utils.hpp"

#include "types.hpp"

#include "exif.hpp"

#include "easyaccess.hpp"

#include "iptc.hpp"

#include "xmp_exiv2.hpp"

#include "preview.hpp"

#include "futils.hpp"

#include "i18n.h"                // NLS support.

// + standard includes

#include <string>

#include <iostream>

#include <iomanip>

#include <fstream>

#include <sstream>

#include <cstring>

#include <cstdio>

#include <ctime>

#include <cmath>

#include <cassert>

#include <stdexcept>

#include <sys/types.h>                  // for stat()

#include <sys/stat.h>                   // for stat()

#ifdef EXV_HAVE_UNISTD_H

# include <unistd.h>                    // for stat()

#endif

#ifdef _MSC_VER

# include <sys/utime.h>

#else

# include <utime.h>

#endif

#if !defined(__MINGW__) && !defined(_MSC_VER)

#define _fileno(a) a

#define _setmode(a,b)

#endif

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

// local declarations

namespace {

    //! Helper class to set the timestamp of a file to that of another file

    class Timestamp {

    public:

        //! C'tor

        Timestamp() : actime_(0), modtime_(0) {}

        //! Read the timestamp of a file

        int read(const std::string& path);

        //! Read the timestamp from a broken-down time in buffer \em tm.

        int read(struct tm* tm);

        //! Set the timestamp of a file

        int touch(const std::string& path);

    private:

        time_t actime_;

        time_t modtime_;

    };

    /*!

      @brief Convert a string "YYYY:MM:DD HH:MI:SS" to a struct tm type,

             returns 0 if successful

     */

    int str2Tm(const std::string& timeStr, struct tm* tm);

    //! Convert a localtime to a string "YYYY:MM:DD HH:MI:SS", "" on error

    std::string time2Str(time_t time);

    //! Convert a tm structure to a string "YYYY:MM:DD HH:MI:SS", "" on error

    std::string tm2Str(const struct tm* tm);

    /*!

      @brief Copy metadata from source to target according to Params::copyXyz

      @param source Source file path

      @param target Target file path. An *.exv file is created if target doesn't

                    exist.

      @param targetType Image type for the target image in case it needs to be

                    created.

      @param preserve Indicates if existing metadata in the target file should

                    be kept.

      @return 0 if successful, else an error code

    */

    int metacopy(const std::string& source,

                 const std::string& target,

                 int targetType,

                 bool preserve);

    /*!

      @brief Rename a file according to a timestamp value.

      @param path The original file path. Contains the new path on exit.

      @param tm   Pointer to a buffer with the broken-down time to rename

                  the file to.

      @return 0 if successful, -1 if the file was skipped, 1 on error.

    */

    int renameFile(std::string& path, const struct tm* tm);

    /*!

      @brief Make a file path from the current file path, destination

             directory (if any) and the filename extension passed in.

      @param path Path of the existing file

      @param ext  New filename extension (incl. the dot '.' if required)

      @return 0 if successful, 1 if the new file exists and the user

             chose not to overwrite it.

     */

    std::string newFilePath(const std::string& path, const std::string& ext);

    /*!

      @brief Check if file \em path exists and whether it should be

             overwritten. Ask user if necessary. Return 1 if the file

             exists and shouldn't be overwritten, else 0.

     */

    int dontOverwrite(const std::string& path);

    /*!

      @brief Output a text with a given minimum number of chars, honoring

             multi-byte characters correctly. Replace code in the form

             os << setw(width) << myString

             with

             os << make_pair( myString, width)

     */

    std::ostream& operator<<( std::ostream& os, std::pair<std::string, int> strAndWidth);

    //! Print image Structure information

    int printStructure(std::ostream& out, Exiv2::PrintStructureOption option, const std::string &path);

}

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

// class member definitions

namespace Action {

    Task::~Task()

    {

    }

    Task::AutoPtr Task::clone() const

    {

        return AutoPtr(clone_());

    }

    TaskFactory* TaskFactory::instance_ = 0;

    TaskFactory& TaskFactory::instance()

    {

        if (0 == instance_) {

            instance_ = new TaskFactory;

        }

        return *instance_;

    } // TaskFactory::instance

    void TaskFactory::cleanup()

    {

        if (instance_ != 0) {

            Registry::iterator e = registry_.end();

            for (Registry::iterator i = registry_.begin(); i != e; ++i) {

                delete i->second;

            }

            delete instance_;

            instance_ = 0;

        }

    } //TaskFactory::cleanup

    void TaskFactory::registerTask(TaskType type, Task::AutoPtr task)

    {

        Registry::iterator i = registry_.find(type);

        if (i != registry_.end()) {

            delete i->second;

        }

        registry_[type] = task.release();

    } // TaskFactory::registerTask

    TaskFactory::TaskFactory()

    {

        // Register a prototype of each known task

        registerTask(adjust,  Task::AutoPtr(new Adjust));

        registerTask(print,   Task::AutoPtr(new Print));

        registerTask(rename,  Task::AutoPtr(new Rename));

        registerTask(erase,   Task::AutoPtr(new Erase));

        registerTask(extract, Task::AutoPtr(new Extract));

        registerTask(insert,  Task::AutoPtr(new Insert));

        registerTask(modify,  Task::AutoPtr(new Modify));

        registerTask(fixiso,  Task::AutoPtr(new FixIso));

        registerTask(fixcom,  Task::AutoPtr(new FixCom));

    } // TaskFactory c'tor

    Task::AutoPtr TaskFactory::create(TaskType type)

    {

        Registry::const_iterator i = registry_.find(type);

        if (i != registry_.end() && i->second != 0) {

            Task* t = i->second;

            return t->clone();

        }

        return Task::AutoPtr(0);

    } // TaskFactory::create

    Print::~Print()

    {

    }

    int setModeAndPrintStructure(Exiv2::PrintStructureOption option, const std::string& path)

    {

        _setmode(_fileno(stdout),O_BINARY);

        return printStructure(std::cout, option, path);

    }

    int Print::run(const std::string& path)

    {

        try {

            path_ = path;

            int rc = 0;

            Exiv2::PrintStructureOption option = Exiv2::kpsNone ;

            switch (Params::instance().printMode_) {

                case Params::pmSummary:   rc = Params::instance().greps_.empty() ? printSummary() : printList(); break;

                case Params::pmList:      rc = printList();        break;

                case Params::pmComment:   rc = printComment();     break;

                case Params::pmPreview:   rc = printPreviewList(); break;

                case Params::pmStructure: rc = printStructure(std::cout,Exiv2::kpsBasic, path_)     ; break;

                case Params::pmRecursive: rc = printStructure(std::cout,Exiv2::kpsRecursive, path_) ; break;

                case Params::pmXMP:

                    if (option == Exiv2::kpsNone)

                        option = Exiv2::kpsXMP;

                    rc = setModeAndPrintStructure(option, path_);

                    break;

                case Params::pmIccProfile:

                    if (option == Exiv2::kpsNone)

                        option = Exiv2::kpsIccProfile;

                    rc = setModeAndPrintStructure(option, path_);

                    break;

            }

            return rc;

        }

        catch(const Exiv2::AnyError& e) {

            std::cerr << "Exiv2 exception in print action for file "

                      << path << ":\n" << e << "\n";

            return 1;

        }

        catch(const std::overflow_error& e) {

            std::cerr << "std::overflow_error exception in print action for file "

                      << path << ":\n" << e.what() << "\n";

            return 1;

        }

    }

    int Print::printSummary()

    {

        if (!Exiv2::fileExists(path_, true)) {

            std::cerr << path_ << ": "

                      << _("Failed to open the file\n");

            return -1;

        }

        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path_);

        assert(image.get() != 0);

        image->readMetadata();

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

        align_ = 16;

        // Filename

        printLabel(_("File name"));

        std::cout << path_ << std::endl;

        // Filesize

        struct stat buf;

        if (0 == stat(path_.c_str(), &buf)) {

            printLabel(_("File size"));

            std::cout << buf.st_size << " " << _("Bytes") << std::endl;

        }

        // MIME type

        printLabel(_("MIME type"));

        std::cout << image->mimeType() << std::endl;

        // Image size

        printLabel(_("Image size"));

        std::cout << image->pixelWidth() << " x " << image->pixelHeight() << std::endl;

        if (exifData.empty()) {

            std::cerr << path_ << ": "

                      << _("No Exif data found in the file\n");

            return -3;

        }

        // Camera make

        printTag(exifData, "Exif.Image.Make", _("Camera make"));

        // Camera model

        printTag(exifData, "Exif.Image.Model", _("Camera model"));

        // Image Timestamp

        printTag(exifData, "Exif.Photo.DateTimeOriginal", _("Image timestamp"));

        // Image number

        // Todo: Image number for cameras other than Canon

        printTag(exifData, "Exif.Canon.FileNumber", _("Image number"));

        // Exposure time

        // From ExposureTime, failing that, try ShutterSpeedValue

        printLabel(_("Exposure time"));

        bool done = 0 != printTag(exifData, "Exif.Photo.ExposureTime");

        if (!done) {

            done = 0 != printTag(exifData, "Exif.Photo.ShutterSpeedValue");

        }

        std::cout << std::endl;

        // Aperture

        // Get if from FNumber and, failing that, try ApertureValue

        {

            printLabel(_("Aperture"));

            bool done = 0 != printTag(exifData, "Exif.Photo.FNumber");

            if (!done) {

                done = 0 != printTag(exifData, "Exif.Photo.ApertureValue");

            }

            std::cout << std::endl;

            // Exposure bias

            printTag(exifData, "Exif.Photo.ExposureBiasValue", _("Exposure bias"));

            // Flash

            printTag(exifData, "Exif.Photo.Flash", _("Flash"));

            // Flash bias

            printTag(exifData, Exiv2::flashBias, _("Flash bias"));

            // Actual focal length and 35 mm equivalent

            // Todo: Calculate 35 mm equivalent a la jhead

            Exiv2::ExifData::const_iterator md;

            printLabel(_("Focal length"));

            if (1 == printTag(exifData, "Exif.Photo.FocalLength")) {

                md = exifData.findKey(

                    Exiv2::ExifKey("Exif.Photo.FocalLengthIn35mmFilm"));

                if (md != exifData.end()) {

                    std::cout << " ("<< _("35 mm equivalent") << ": "

                              << md->print(&exifData) << ")";

                }

            }

            else {

                printTag(exifData, "Exif.Canon.FocalLength");

            }

            std::cout << std::endl;

        }

        // Subject distance

        {

            printLabel(_("Subject distance"));

            bool done = 0 != printTag(exifData, "Exif.Photo.SubjectDistance");

            if (!done) {

                printTag(exifData, "Exif.CanonSi.SubjectDistance");

                printTag(exifData, "Exif.CanonFi.FocusDistanceLower");

                printTag(exifData, "Exif.CanonFi.FocusDistanceUpper");

            }

            std::cout << std::endl;

        }

        // ISO speed

        printTag(exifData, Exiv2::isoSpeed, _("ISO speed"));

        // Exposure mode

        printTag(exifData, Exiv2::exposureMode, _("Exposure mode"));

        // Metering mode

        printTag(exifData, "Exif.Photo.MeteringMode", _("Metering mode"));

        // Macro mode

        printTag(exifData, Exiv2::macroMode, _("Macro mode"));

        // Image quality setting (compression)

        printTag(exifData, Exiv2::imageQuality, _("Image quality"));

        // Exif Resolution

        {

            printLabel(_("Exif Resolution"));

            long xdim = 0;

            long ydim = 0;

            if (image->mimeType() == "image/tiff") {

                xdim = image->pixelWidth();

                ydim = image->pixelHeight();

            }

            else {

                Exiv2::ExifData::const_iterator md = exifData.findKey(Exiv2::ExifKey("Exif.Image.ImageWidth"));

                if (md == exifData.end()) {

                    md = exifData.findKey(Exiv2::ExifKey("Exif.Photo.PixelXDimension"));

                }

                if (md != exifData.end() && md->count() > 0) {

                    xdim = md->toLong();

                }

                md = exifData.findKey(Exiv2::ExifKey("Exif.Image.ImageLength"));

                if (md == exifData.end()) {

                    md = exifData.findKey(Exiv2::ExifKey("Exif.Photo.PixelYDimension"));

                }

                if (md != exifData.end() && md->count() > 0) {

                    ydim = md->toLong();

                }

            }

            if (xdim != 0 && ydim != 0) {

                std::cout << xdim << " x " << ydim;

            }

            std::cout << std::endl;

        }

        // White balance

        printTag(exifData, Exiv2::whiteBalance, _("White balance"));

        // Thumbnail

        printLabel(_("Thumbnail"));

        Exiv2::ExifThumbC exifThumb(exifData);

        std::string thumbExt = exifThumb.extension();

        if (thumbExt.empty()) {

            std::cout << _("None");

        }

        else {

            Exiv2::DataBuf buf = exifThumb.copy();

            if (buf.size_ == 0) {

                std::cout << _("None");

            }

            else {

                std::cout << exifThumb.mimeType() << ", "

                          << buf.size_ << " " << _("Bytes");

            }

        }

        std::cout << std::endl;

        // Copyright

        printTag(exifData, "Exif.Image.Copyright", _("Copyright"));

        // Exif Comment

        printTag(exifData, "Exif.Photo.UserComment", _("Exif comment"));

        std::cout << std::endl;

        return 0;

    } // Print::printSummary

    void Print::printLabel(const std::string& label) const

    {

        std::cout << std::setfill(' ') << std::left;

        if (Params::instance().files_.size() > 1) {

            std::cout << std::setw(20) << path_ << " ";

        }

        std::cout << std::make_pair( label, align_)

                  << ": ";

    }

    int Print::printTag(const Exiv2::ExifData& exifData,

                        const std::string& key,

                        const std::string& label) const

    {

        int rc = 0;

        if (!label.empty()) {

            printLabel(label);

        }

        Exiv2::ExifKey ek(key);

        Exiv2::ExifData::const_iterator md = exifData.findKey(ek);

        if (md != exifData.end()) {

            md->write(std::cout, &exifData);

            rc = 1;

        }

        if (!label.empty()) std::cout << std::endl;

        return rc;

    } // Print::printTag

    int Print::printTag(const Exiv2::ExifData& exifData,

                        EasyAccessFct easyAccessFct,

                        const std::string& label) const

    {

        int rc = 0;

        if (!label.empty()) {

            printLabel(label);

        }

        Exiv2::ExifData::const_iterator md = easyAccessFct(exifData);

        if (md != exifData.end()) {

            md->write(std::cout, &exifData);

            rc = 1;

        }

        if (!label.empty()) std::cout << std::endl;

        return rc;

    } // Print::printTag

    int Print::printList()

    {

        if (!Exiv2::fileExists(path_, true)) {

            std::cerr << path_

                      << ": " << _("Failed to open the file\n");

            return -1;

        }

        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path_);

        assert(image.get() != 0);

        image->readMetadata();

        // Set defaults for metadata types and data columns

        if (Params::instance().printTags_ == Exiv2::mdNone) {

            Params::instance().printTags_ = Exiv2::mdExif | Exiv2::mdIptc | Exiv2::mdXmp;

        }

        if (Params::instance().printItems_ == 0) {

            Params::instance().printItems_ = Params::prKey | Params::prType | Params::prCount | Params::prTrans;

        }

        return printMetadata(image.get());

    } // Print::printList

    int Print::printMetadata(const Exiv2::Image* image)

    {

        bool ret = false;

        bool noExif = false;

        if (Params::instance().printTags_ & Exiv2::mdExif) {

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

            for (Exiv2::ExifData::const_iterator md = exifData.begin();

                 md != exifData.end(); ++md) {

                ret |= printMetadatum(*md, image);

            }

            if (exifData.empty()) noExif = true;

        }

        bool noIptc = false;

        if (Params::instance().printTags_ & Exiv2::mdIptc) {

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

            for (Exiv2::IptcData::const_iterator md = iptcData.begin();

                 md != iptcData.end(); ++md) {

                ret |= printMetadatum(*md, image);

            }

            if (iptcData.empty()) noIptc = true;

        }

        bool noXmp = false;

        if (Params::instance().printTags_ & Exiv2::mdXmp) {

            const Exiv2::XmpData& xmpData = image->xmpData();

            for (Exiv2::XmpData::const_iterator md = xmpData.begin();

                 md != xmpData.end(); ++md) {

                ret |= printMetadatum(*md, image);

            }

            if (xmpData.empty()) noXmp = true;

        }

        // With -v, inform about the absence of any (requested) type of metadata

        if (Params::instance().verbose_) {

            if (noExif) std::cerr << path_ << ": " << _("No Exif data found in the file\n");

            if (noIptc) std::cerr << path_ << ": " << _("No IPTC data found in the file\n");

            if (noXmp)  std::cerr << path_ << ": " << _("No XMP data found in the file\n");

        }

        // With -g or -K, return -3 if no matching tags were found

        int rc = 0;

        if ((!Params::instance().greps_.empty() || !Params::instance().keys_.empty()) && !ret) rc = 1;

        return rc;

    } // Print::printMetadata

    bool Print::grepTag(const std::string& key)

    {

        bool result=Params::instance().greps_.empty();

        for (Params::Greps::const_iterator g = Params::instance().greps_.begin();

                !result && g != Params::instance().greps_.end(); ++g)

        {

#if defined(EXV_HAVE_REGEX_H)

            result = regexec( &(*g), key.c_str(), 0, NULL, 0) == 0 ;

#else

            std::string Pattern(g->pattern_);

            std::string Key(key);

            if ( g->bIgnoreCase_ ) {

                // https://notfaq.wordpress.com/2007/08/04/cc-convert-string-to-upperlower-case/

                std::transform(Pattern.begin(), Pattern.end(),Pattern.begin(), ::tolower);

                std::transform(Key.begin()    , Key.end()    ,Key.begin()    , ::tolower);

            }

            result = Key.find(Pattern) != std::string::npos;

#endif

        }

        return result ;

    }

    bool Print::keyTag(const std::string& key)

    {

        bool result=Params::instance().keys_.empty();

        for (Params::Keys::const_iterator k = Params::instance().keys_.begin();

                !result && k != Params::instance().keys_.end(); ++k)

        {

            result = key.compare(*k) == 0;

        }

        return result ;

    }

    bool Print::printMetadatum(const Exiv2::Metadatum& md, const Exiv2::Image* pImage)

    {

        if (!grepTag(md.key()))

            return false;

        if (!keyTag(md.key()))

            return false;

        if (Params::instance().unknown_ && md.tagName().substr(0, 2) == "0x") {

            return false;

        }

        bool const manyFiles = Params::instance().files_.size() > 1;

        if (manyFiles) {

            std::cout << std::setfill(' ') << std::left << std::setw(20) << path_ << "  ";

        }

        bool first = true;

        if (Params::instance().printItems_ & Params::prTag) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << "0x" << std::setw(4) << std::setfill('0') << std::right << std::hex << md.tag();

        }

        if (Params::instance().printItems_ & Params::prSet) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << "set";

        }

        if (Params::instance().printItems_ & Params::prGroup) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::setw(12) << std::setfill(' ') << std::left << md.groupName();

        }

        if (Params::instance().printItems_ & Params::prKey) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::setfill(' ') << std::left << std::setw(44) << md.key();

        }

        if (Params::instance().printItems_ & Params::prName) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::setw(27) << std::setfill(' ') << std::left << md.tagName();

        }

        if (Params::instance().printItems_ & Params::prLabel) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::setw(30) << std::setfill(' ') << std::left << md.tagLabel();

        }

        if (Params::instance().printItems_ & Params::prType) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::setw(9) << std::setfill(' ') << std::left;

            const char* tn = md.typeName();

            if (tn) {

                std::cout << tn;

            } else {

                std::ostringstream os;

                os << "0x" << std::setw(4) << std::setfill('0') << std::hex << md.typeId();

                std::cout << os.str();

            }

        }

        if (Params::instance().printItems_ & Params::prCount) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::dec << std::setw(3) << std::setfill(' ') << std::right << md.count();

        }

        if (Params::instance().printItems_ & Params::prSize) {

            if (!first)

                std::cout << " ";

            first = false;

            std::cout << std::dec << std::setw(3) << std::setfill(' ') << std::right << md.size();

        }

        if (Params::instance().printItems_ & Params::prValue && md.size() > 0) {

            if (!first)

                std::cout << "  ";

            first = false;

            if (md.size() > 128 && Params::instance().binary_ &&

                (md.typeId() == Exiv2::undefined || md.typeId() == Exiv2::unsignedByte ||

                 md.typeId() == Exiv2::signedByte)) {

                std::cout << _("(Binary value suppressed)") << std::endl;

                return true;

            }

            bool done = false;

            if (0 == strcmp(md.key().c_str(), "Exif.Photo.UserComment")) {

                const Exiv2::CommentValue* pcv = dynamic_cast<const Exiv2::CommentValue*>(&md.value());

                if (pcv) {

                    Exiv2::CommentValue::CharsetId csId = pcv->charsetId();

                    if (csId != Exiv2::CommentValue::undefined) {

                        std::cout << "charset=\"" << Exiv2::CommentValue::CharsetInfo::name(csId) << "\" ";

                    }

                    std::cout << pcv->comment(Params::instance().charset_.c_str());

                    done = true;

                }

            }

            if (!done) {

                // #1114 - show negative values for SByte

                if (md.typeId() != Exiv2::signedByte) {

                    std::cout << std::dec << md.value();

                } else {

                    int value = md.value().toLong();

                    std::cout << std::dec << (value < 128 ? value : value - 256);

                }

            }

        }

        if (Params::instance().printItems_ & Params::prTrans) {

            if (!first)

                std::cout << "  ";

            first = false;

            if (Params::instance().binary_ &&

                (md.typeId() == Exiv2::undefined || md.typeId() == Exiv2::unsignedByte ||

                 md.typeId() == Exiv2::signedByte) &&

                md.size() > 128) {

                std::cout << _("(Binary value suppressed)") << std::endl;

                return true;

            }

            bool done = false;

            if (0 == strcmp(md.key().c_str(), "Exif.Photo.UserComment")) {

                const Exiv2::CommentValue* pcv = dynamic_cast<const Exiv2::CommentValue*>(&md.value());

                if (pcv) {

                    std::cout << pcv->comment(Params::instance().charset_.c_str());

                    done = true;

                }

            }

            if (!done)

                std::cout << std::dec << md.print(&pImage->exifData());

        }

        if (Params::instance().printItems_ & Params::prHex) {

            if (!first)

                std::cout << std::endl;

            first = false;

            if (Params::instance().binary_ &&

                (md.typeId() == Exiv2::undefined || md.typeId() == Exiv2::unsignedByte ||

                 md.typeId() == Exiv2::signedByte) &&

                md.size() > 128) {

                std::cout << _("(Binary value suppressed)") << std::endl;

                return true;

            }

            Exiv2::DataBuf buf(md.size());

            md.copy(buf.pData_, pImage->byteOrder());

            Exiv2::hexdump(std::cout, buf.pData_, buf.size_);

        }

        std::cout << std::endl;

        return true;

    }  // Print::printMetadatum

    int Print::printComment()

    {

        if (!Exiv2::fileExists(path_, true)) {

            std::cerr << path_

                      << ": " << _("Failed to open the file\n");

            return -1;

        }

        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path_);

        assert(image.get() != 0);

        image->readMetadata();

        if (Params::instance().verbose_) {

            std::cout << _("JPEG comment") << ": ";

        }

        std::cout << image->comment() << std::endl;

        return 0;

    } // Print::printComment

    int Print::printPreviewList()

    {

        if (!Exiv2::fileExists(path_, true)) {

            std::cerr << path_

                      << ": " << _("Failed to open the file\n");

            return -1;

        }

        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path_);

        assert(image.get() != 0);

        image->readMetadata();

        bool const manyFiles = Params::instance().files_.size() > 1;

        int cnt = 0;

        Exiv2::PreviewManager pm(*image);

        Exiv2::PreviewPropertiesList list = pm.getPreviewProperties();

        for (Exiv2::PreviewPropertiesList::const_iterator pos = list.begin(); pos != list.end(); ++pos) {

            if (manyFiles) {

                std::cout << std::setfill(' ') << std::left << std::setw(20)

                          << path_ << "  ";

            }

            std::cout << _("Preview") << " " << ++cnt << ": "

                      << pos->mimeType_ << ", ";

            if (pos->width_ != 0 && pos->height_ != 0) {

                std::cout << pos->width_ << "x" << pos->height_ << " "

                          << _("pixels") << ", ";

            }

            std::cout << pos->size_ << " " << _("bytes") << "\n";

        }

        return 0;

    } // Print::printPreviewList

    Print::AutoPtr Print::clone() const

    {

        return AutoPtr(clone_());

    }

    Print* Print::clone_() const

    {

        return new Print(*this);

    }

    Rename::~Rename()

    {

    }

    int Rename::run(const std::string& path)

    {

    try {

        if (!Exiv2::fileExists(path, true)) {

            std::cerr << path

                      << ": " << _("Failed to open the file\n");

            return -1;

        }

        Timestamp ts;

        if (Params::instance().preserve_) ts.read(path);

        Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(path);

        assert(image.get() != 0);

        image->readMetadata();

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

        if (exifData.empty()) {

            std::cerr << path

                      << ": " << _("No Exif data found in the file\n");

            return -3;

        }

        Exiv2::ExifKey key("Exif.Photo.DateTimeOriginal");

        Exiv2::ExifData::iterator md = exifData.findKey(key);

        if (md == exifData.end()) {

            key = Exiv2::ExifKey("Exif.Image.DateTime");

            md = exifData.findKey(key);

        }

        if (md == exifData.end()) {

            std::cerr << _("Neither tag") << " `Exif.Photo.DateTimeOriginal' "

                      << _("nor") << " `Exif.Image.DateTime' "

                      << _("found in the file") << " " << path << "\n";

            return 1;

        }

        std::string v = md->toString();

        if (v.length() == 0 || v[0] == ' ') {

            std::cerr << _("Image file creation timestamp not set in the file")

                      << " " << path << "\n";

            return 1;

        }

        struct tm tm;

        if (str2Tm(v, &tm) != 0) {

            std::cerr << _("Failed to parse timestamp") << " `" << v

                      << "' " << _("in the file") << " " << path << "\n";

            return 1;

        }

        if (   Params::instance().timestamp_

            || Params::instance().timestampOnly_) {

            ts.read(&tm;;

        }

        int rc = 0;

        std::string newPath = path;

        if (Params::instance().timestampOnly_) {

            if (Params::instance().verbose_) {

                std::cout << _("Updating timestamp to") << " " << v << std::endl;

            }

        }

        else {

            rc = renameFile(newPath, &tm;;

            if (rc == -1) return 0; // skip

        }