/*
 * libopenraw - ifdentry.cpp
 *
 * Copyright (C) 2006-2017 Hubert Figuière
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <http://www.gnu.org/licenses/>.
 */


#include <stdlib.h>
#include <math.h>

#include <cstdint>
#include <string>

#include <libopenraw/debug.h>

#include "metavalue.hpp"
#include "trace.hpp"
#include "ifdfilecontainer.hpp"
#include "ifdentry.hpp"
#include "ifd.hpp"

using namespace Debug;

namespace OpenRaw {
namespace Internals {


IfdEntry::IfdEntry(uint16_t _id, int16_t _type,
                   int32_t _count, uint32_t _data,
                   IfdFileContainer &_container)
    : m_id(_id), m_type(_type),
      m_count(_count), m_data(_data),
      m_loaded(false), m_dataptr(NULL),
      m_container(_container)
{
	auto container_size = m_container.size();
	auto unit_size = type_unit_size(static_cast<IFD::ExifTagType>(m_type));
	if ((m_count * unit_size) > static_cast<size_t>(container_size)) {
		LOGERR("Trying to have %u items in a container of %ld bytes\n",
			   m_count, container_size);
		m_count = container_size / unit_size;
	}
}


IfdEntry::~IfdEntry()
{
    if (m_dataptr) {
        free(m_dataptr);
    }
}

namespace {

template <class T>
void convert(Internals::IfdEntry* e, std::vector<MetaValue::value_t> & values)
{
    auto result = e->getArray<T>();
    if (result.ok()) {
        std::vector<T> v = result.unwrap();
        values.insert(values.end(), v.cbegin(), v.cend());
    }
}

// T is the Ifd primitive type. T2 is the target MetaValue type.
template <class T, class T2>
void convert(Internals::IfdEntry* e, std::vector<MetaValue::value_t> & values)
{
    auto result = e->getArray<T>();
    if (result.ok()) {
        std::vector<T> v = result.unwrap();
        for(const auto & elem : v) {
            values.push_back(T2(elem));
        }
    }
}

}


size_t IfdEntry::type_unit_size(IFD::ExifTagType _type)
{
	switch(_type) {
    case IFD::EXIF_FORMAT_BYTE:
    case IFD::EXIF_FORMAT_SBYTE:
    case IFD::EXIF_FORMAT_ASCII:
    case IFD::EXIF_FORMAT_UNDEFINED:
		return 1;
    case IFD::EXIF_FORMAT_SHORT:
    case IFD::EXIF_FORMAT_SSHORT:
		return 2;
    case IFD::EXIF_FORMAT_LONG:
    case IFD::EXIF_FORMAT_SLONG:
    case IFD::EXIF_FORMAT_FLOAT:
		return 4;
    case IFD::EXIF_FORMAT_RATIONAL:
    case IFD::EXIF_FORMAT_SRATIONAL:
    case IFD::EXIF_FORMAT_DOUBLE:
		return 8;
	}

	return 0;
}
MetaValue* IfdEntry::make_meta_value()
{
    std::vector<MetaValue::value_t> values;

    switch(type()) {
    case Internals::IFD::EXIF_FORMAT_BYTE:
    {
        convert<uint8_t, uint32_t>(this, values);
        break;
    }
    case Internals::IFD::EXIF_FORMAT_ASCII:
    {
        convert<std::string>(this, values);
        break;
    }
    case Internals::IFD::EXIF_FORMAT_SHORT:
    {
        convert<uint16_t, uint32_t>(this, values);
        break;
    }
    case Internals::IFD::EXIF_FORMAT_LONG:
    {
        convert<uint32_t>(this, values);
        break;
    }
    case Internals::IFD::EXIF_FORMAT_SRATIONAL:
    {
        convert<Internals::IFD::SRational, double>(this, values);
        break;
    }
    default:
        LOGDBG1("unhandled type %d\n", type());
        return NULL;
    }
    return new MetaValue(values);
}

RawContainer::EndianType IfdEntry::endian() const
{
	return m_container.endian();
}


bool IfdEntry::loadData(size_t unit_size)
{
	bool success = false;
	size_t data_size = unit_size * m_count;
	if (data_size <= 4) {
		m_dataptr = NULL;
		success = true;
	}
	else {
		off_t _offset;
		if (endian() == RawContainer::ENDIAN_LITTLE) {
			_offset = IfdTypeTrait<uint32_t>::EL((uint8_t*)&m_data, sizeof(uint32_t));
		} else {
			_offset = IfdTypeTrait<uint32_t>::BE((uint8_t*)&m_data, sizeof(uint32_t));
		}
		_offset += m_container.exifOffsetCorrection();
		m_dataptr = (uint8_t*)realloc(m_dataptr, data_size);
		success = (m_container.fetchData(m_dataptr,
										 _offset,
										 data_size) == data_size);
	}
	return success;
}

uint32_t IfdEntry::getIntegerArrayItem(int idx)
{
    uint32_t v = 0;

    try {
        switch(type())
        {
        case IFD::EXIF_FORMAT_LONG:
            v = IfdTypeTrait<uint32_t>::get(*this, idx);
            break;
        case IFD::EXIF_FORMAT_SHORT:
            v = IfdTypeTrait<uint16_t>::get(*this, idx);
            break;
        case IFD::EXIF_FORMAT_RATIONAL:
        {
            IFD::Rational r = IfdTypeTrait<IFD::Rational>::get(*this, idx);
            if(r.denom == 0) {
                v = 0;
            }
            else {
                v = r.num / r.denom;
            }
            break;
        }
        default:
            break;
        }
    }
    catch(const std::exception & ex) {
        LOGERR("Exception raised %s fetch integer value for %d\n", ex.what(), m_id);
    }

    return v;
}


namespace IFD {

Rational::operator double() const
{
	if(denom == 0) {
		return INFINITY;
	}
	return (double)num / (double)denom;
}

SRational::operator double() const
{
	if(denom == 0) {
		return INFINITY;
	}
	return (double)num / (double)denom;
}

}

template <>
const uint16_t IfdTypeTrait<uint8_t>::type = IFD::EXIF_FORMAT_BYTE;
template <>
const size_t IfdTypeTrait<uint8_t>::size = 1;

template <>
const uint16_t IfdTypeTrait<uint16_t>::type = IFD::EXIF_FORMAT_SHORT;
template <>
const size_t IfdTypeTrait<uint16_t>::size = 2;

template <>
const uint16_t IfdTypeTrait<IFD::Rational>::type = IFD::EXIF_FORMAT_RATIONAL;
template <>
const size_t IfdTypeTrait<IFD::Rational>::size = 8;

template <>
const uint16_t IfdTypeTrait<IFD::SRational>::type = IFD::EXIF_FORMAT_SRATIONAL;
template <>
const size_t IfdTypeTrait<IFD::SRational>::size = 8;


template <>
const uint16_t IfdTypeTrait<uint32_t>::type = IFD::EXIF_FORMAT_LONG;
template <>
const size_t IfdTypeTrait<uint32_t>::size = 4;

template <>
const uint16_t IfdTypeTrait<std::string>::type = IFD::EXIF_FORMAT_ASCII;
template <>
const size_t IfdTypeTrait<std::string>::size = 1;
}
}
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0))
  tab-width:4
  c-basic-offset:4
  indent-tabs-mode:t
  fill-column:80
  End:
*/