/*
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <img_utils/TiffIfd.h>
#include <img_utils/TiffHelpers.h>
#include <img_utils/TiffEntry.h>

#include <utils/Errors.h>
#include <utils/StrongPointer.h>

#include <utils/Log.h>

namespace android {
namespace img_utils {

TiffEntry::~TiffEntry() {}

/**
 * Specialize for each valid type, including sub-IFDs.
 *
 * Values with types other than the ones given here should not compile.
 */

template<>
const sp<TiffIfd>* TiffEntry::forceValidType<sp<TiffIfd> >(TagType type, const sp<TiffIfd>* value) {
    if (type == LONG) {
        return value;
    }
    ALOGE("%s: Value of type 'ifd' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const uint8_t* TiffEntry::forceValidType<uint8_t>(TagType type, const uint8_t* value) {
    if (type == BYTE || type == ASCII || type == UNDEFINED) {
        return value;
    }
    ALOGE("%s: Value of type 'uint8_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const int8_t* TiffEntry::forceValidType<int8_t>(TagType type, const int8_t* value) {
    if (type == SBYTE || type == ASCII || type == UNDEFINED) {
        return value;
    }
    ALOGE("%s: Value of type 'int8_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const uint16_t* TiffEntry::forceValidType<uint16_t>(TagType type, const uint16_t* value) {
    if (type == SHORT) {
        return value;
    }
    ALOGE("%s: Value of type 'uint16_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const int16_t* TiffEntry::forceValidType<int16_t>(TagType type, const int16_t* value) {
    if (type == SSHORT) {
        return value;
    }
    ALOGE("%s: Value of type 'int16_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const uint32_t* TiffEntry::forceValidType<uint32_t>(TagType type, const uint32_t* value) {
    if (type == LONG || type == RATIONAL) {
        return value;
    }
    ALOGE("%s: Value of type 'uint32_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const int32_t* TiffEntry::forceValidType<int32_t>(TagType type, const int32_t* value) {
    if (type == SLONG || type == SRATIONAL) {
        return value;
    }
    ALOGE("%s: Value of type 'int32_t' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const double* TiffEntry::forceValidType<double>(TagType type, const double* value) {
    if (type == DOUBLE) {
        return value;
    }
    ALOGE("%s: Value of type 'double' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

template<>
const float* TiffEntry::forceValidType<float>(TagType type, const float* value) {
    if (type == FLOAT) {
        return value;
    }
    ALOGE("%s: Value of type 'float' is not valid for tag with TIFF type %d.",
            __FUNCTION__, type);
    return NULL;
}

std::string TiffEntry::toString() const {
    std::string output;
    uint32_t count = getCount();
    char buf[256] = { 0 };
    snprintf(buf, sizeof(buf), "[id: %x, type: %d, count: %u, value: '", getTag(), getType(), count);
    output.append(buf);

    size_t cappedCount = count;
    if (count > MAX_PRINT_STRING_LENGTH) {
        cappedCount = MAX_PRINT_STRING_LENGTH;
    }

    TagType type = getType();
    switch (type) {
        case UNDEFINED:
        case BYTE: {
            const uint8_t* typed_data = getData<uint8_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case ASCII: {
            const char* typed_data = reinterpret_cast<const char*>(getData<uint8_t>());
            size_t len = count;
            if (count > MAX_PRINT_STRING_LENGTH) {
                 len = MAX_PRINT_STRING_LENGTH;
            }
            output.append(typed_data, len);
            break;
        }
        case SHORT: {
            const uint16_t* typed_data = getData<uint16_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case LONG: {
            const uint32_t* typed_data = getData<uint32_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case RATIONAL: {
            const uint32_t* typed_data = getData<uint32_t>();
            cappedCount <<= 1;
            for (size_t i = 0; i < cappedCount; i+=2) {
                output.append(std::to_string(typed_data[i]));
                output.append("/");
                output.append(std::to_string(typed_data[i + 1]));
                output.append(" ");
            }
            break;
        }
        case SBYTE: {
            const int8_t* typed_data = getData<int8_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case SSHORT: {
            const int16_t* typed_data = getData<int16_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case SLONG: {
            const int32_t* typed_data = getData<int32_t>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case SRATIONAL: {
            const int32_t* typed_data = getData<int32_t>();
            cappedCount <<= 1;
            for (size_t i = 0; i < cappedCount; i+=2) {
                output.append(std::to_string(typed_data[i]));
                output.append("/");
                output.append(std::to_string(typed_data[i + 1]));
                output.append(" ");
            }
            break;
        }
        case FLOAT: {
            const float* typed_data = getData<float>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        case DOUBLE: {
            const double* typed_data = getData<double>();
            for (size_t i = 0; i < cappedCount; ++i) {
                output.append(std::to_string(typed_data[i]));
                output.append(" ");
            }
            break;
        }
        default: {
            output.append("unknown type ");
            break;
        }
    }

    if (count > MAX_PRINT_STRING_LENGTH) {
        output.append("...");
    }
    output.append("']");
    return output;
}

} /*namespace img_utils*/
} /*namespace android*/
