/*
 * Copyright (c) 2008-2015 Freescale Semiconductor, Inc.
 * Copyright 2016-2018 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "DataSourceImager.h"
#include <stdlib.h>
#include <string.h>

using namespace elftosb;

DataSourceImager::DataSourceImager()
    : Blob()
    , m_fill(0)
    , m_baseAddress(0)
    , m_isBaseAddressSet(false)
{
}

void DataSourceImager::setBaseAddress(uint32_t address)
{
    m_baseAddress = address;
    m_isBaseAddressSet = true;
}

void DataSourceImager::setFillPattern(uint8_t pattern)
{
    m_fill = pattern;
}

void DataSourceImager::reset()
{
    clear();

    m_fill = 0;
    m_baseAddress = 0;
    m_isBaseAddressSet = false;
}

//! \param dataSource Pointer to an instance of a concrete data source subclass.
//!
void DataSourceImager::addDataSource(DataSource *source)
{
    unsigned segmentCount = source->getSegmentCount();
    unsigned index = 0;
    for (; index < segmentCount; ++index)
    {
        addDataSegment(source->getSegmentAt(index));
    }
}

//! \param segment The segment to add. May be any type of data segment, including
//!		a pattern segment.
void DataSourceImager::addDataSegment(DataSource::Segment *segment)
{
    DataSource::PatternSegment *patternSegment = dynamic_cast<DataSource::PatternSegment *>(segment);

    unsigned segmentLength = segment->getLength();
    bool segmentHasLocation = segment->hasNaturalLocation();
    uint32_t segmentAddress = segment->getBaseAddress();

    uint8_t *toPtr = NULL;
    unsigned addressDelta;
    unsigned newLength;

    // If a pattern segment's length is 0 then make it as big as the fill pattern.
    // This needs to be done before the buffer is adjusted.
    if (patternSegment && segmentLength == 0)
    {
        SizedIntegerValue &pattern = patternSegment->getPattern();
        segmentLength = pattern.getSize();
    }

    if (segmentLength)
    {
        if (segmentHasLocation)
        {
            // Make sure a base address is set.
            if (!m_isBaseAddressSet)
            {
                m_baseAddress = segmentAddress;
                m_isBaseAddressSet = true;
            }

            // The segment is located before our buffer's first address.
            // toPtr is not set in this if, but in the else branch of the next if.
            // Unless the segment completely overwrite the current data.
            if (segmentAddress < m_baseAddress)
            {
                addressDelta = m_baseAddress - segmentAddress;

                uint8_t *newData = (uint8_t *)malloc(m_length + addressDelta);
                memcpy(&newData[addressDelta], m_data, m_length);
                free(m_data);

                m_data = newData;
                m_length += addressDelta;
                m_baseAddress = segmentAddress;
            }

            // This segment is located or extends outside of our buffer.
            if (segmentAddress + segmentLength > m_baseAddress + m_length)
            {
                newLength = segmentAddress + segmentLength - m_baseAddress;

                m_data = (uint8_t *)realloc(m_data, newLength);

                // Clear any bytes between the old data and the new segment.
                addressDelta = segmentAddress - (m_baseAddress + m_length);
                if (addressDelta)
                {
                    memset(m_data + m_length, 0, addressDelta);
                }

                toPtr = m_data + (segmentAddress - m_baseAddress);
                m_length = newLength;
            }
            else
            {
                toPtr = m_data + (segmentAddress - m_baseAddress);
            }
        }
        // Segment has no natural location, so just append it to the end of our buffer.
        else
        {
            newLength = m_length + segmentLength;
            m_data = (uint8_t *)realloc(m_data, newLength);
            toPtr = m_data + m_length;
            m_length = newLength;
        }
    }

    // A loop is used because getData() may fill in less than the requested
    // number of bytes per call.
    unsigned offset = 0;
    while (offset < segmentLength)
    {
        offset += segment->getData(offset, segmentLength - offset, toPtr + offset);
    }
}
