/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you 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 .

 */

#include <algorithm>

#include <limits>

#include <set>

#include <string.h>

#include <com/sun/star/io/IOException.hpp>

#include <com/sun/star/io/XInputStream.hpp>

#include <com/sun/star/io/XOutputStream.hpp>

#include <com/sun/star/io/XSeekable.hpp>

#include <o3tl/safeint.hxx>

#include <osl/diagnose.h>

#include <svl/instrm.hxx>

#include <svl/outstrm.hxx>

#include <utility>

using namespace com::sun::star;

class SvDataPipe_Impl

{

public:

    enum SeekResult { SEEK_BEFORE_MARKED, SEEK_OK, SEEK_PAST_END };

private:

    struct Page

    {

        Page * m_pPrev;

        Page * m_pNext;

        sal_Int8 * m_pStart;

        sal_Int8 * m_pRead;

        sal_Int8 * m_pEnd;

        sal_uInt32 m_nOffset;

        sal_Int8 m_aBuffer[1];

    };

    static const sal_uInt32 m_nPageSize = 1000;

    std::multiset< sal_uInt32 > m_aMarks;

    Page * m_pFirstPage;

    Page * m_pReadPage;

    Page * m_pWritePage;

    sal_Int8 * m_pReadBuffer;

    sal_uInt32 m_nReadBufferSize;

    sal_uInt32 m_nReadBufferFilled;

    sal_uInt32 m_nPages;

    bool m_bEOF;

    void remove(Page * pPage);

public:

    inline SvDataPipe_Impl();

    ~SvDataPipe_Impl();

    inline void setReadBuffer(sal_Int8 * pBuffer, sal_uInt32 nSize);

    sal_uInt32 read();

    void clearReadBuffer() { m_pReadBuffer = nullptr; }

    void write(sal_Int8 const * pBuffer, sal_uInt32 nSize);

    void setEOF() { m_bEOF = true; }

    inline bool isEOF() const;

    SeekResult setReadPosition(sal_uInt32 nPosition);

};

SvDataPipe_Impl::SvDataPipe_Impl()

    : m_pFirstPage( nullptr )

    , m_pReadPage( nullptr )

    , m_pWritePage( nullptr )

    , m_pReadBuffer( nullptr )

    , m_nReadBufferSize( 0 )

    , m_nReadBufferFilled( 0 )

    , m_nPages( 0 )

    , m_bEOF( false )

{}

inline void SvDataPipe_Impl::setReadBuffer(sal_Int8 * pBuffer,

                                           sal_uInt32 nSize)

{

    m_pReadBuffer = pBuffer;

    m_nReadBufferSize = nSize;

    m_nReadBufferFilled = 0;

}

inline bool SvDataPipe_Impl::isEOF() const

{

    return m_bEOF && m_pReadPage == m_pWritePage

           && (!m_pReadPage || m_pReadPage->m_pRead == m_pReadPage->m_pEnd);

}

//  SvInputStream

bool SvInputStream::open()

{

    if (GetError() != ERRCODE_NONE)

        return false;

    if (!(m_xSeekable.is() || m_pPipe))

    {

        if (!m_xStream.is())

        {

            SetError(ERRCODE_IO_INVALIDDEVICE);

            return false;

        }

        m_xSeekable.set(m_xStream, uno::UNO_QUERY);

        if (!m_xSeekable.is())

            m_pPipe.reset( new SvDataPipe_Impl );

    }

    return true;

}

// virtual

std::size_t SvInputStream::GetData(void * pData, std::size_t const nSize)

{

    if (!open())

    {

        SetError(ERRCODE_IO_CANTREAD);

        return 0;

    }

    // check if a truncated STREAM_SEEK_TO_END was passed

    assert(m_nSeekedFrom != SAL_MAX_UINT32);

    sal_uInt32 nRead = 0;

    if (m_xSeekable.is())

    {

        if (m_nSeekedFrom != STREAM_SEEK_TO_END)

        {

            try

            {

                m_xSeekable->seek(m_nSeekedFrom);

            }

            catch (const io::IOException&)

            {

                SetError(ERRCODE_IO_CANTREAD);

                return 0;

            }

            m_nSeekedFrom = STREAM_SEEK_TO_END;

        }

        for (;;)

        {

            sal_Int32 nRemain

                = sal_Int32(

                    std::min(std::size_t(nSize - nRead),

                             std::size_t(std::numeric_limits<sal_Int32>::max())));

            if (nRemain == 0)

                break;

            uno::Sequence< sal_Int8 > aBuffer;

            sal_Int32 nCount;

            try

            {

                nCount = m_xStream->readBytes(aBuffer, nRemain);

            }

            catch (const io::IOException&)

            {

                SetError(ERRCODE_IO_CANTREAD);

                return nRead;

            }

            memcpy(static_cast< sal_Int8 * >(pData) + nRead,

                           aBuffer.getConstArray(), sal_uInt32(nCount));

            nRead += nCount;

            if (nCount < nRemain)

                break;

        }

    }

    else

    {

        if (m_nSeekedFrom != STREAM_SEEK_TO_END)

        {

            SetError(ERRCODE_IO_CANTREAD);

            return 0;

        }

        m_pPipe->setReadBuffer(static_cast< sal_Int8 * >(pData), nSize);

        nRead = m_pPipe->read();

        if (nRead < nSize && !m_pPipe->isEOF())

            for (;;)

            {

                sal_Int32 nRemain

                    = sal_Int32(

                        std::min(

                            std::size_t(nSize - nRead),

                            std::size_t(std::numeric_limits<sal_Int32>::max())));

                if (nRemain == 0)

                    break;

                uno::Sequence< sal_Int8 > aBuffer;

                sal_Int32 nCount;

                try

                {

                    nCount = m_xStream->readBytes(aBuffer, nRemain);

                }

                catch (const io::IOException&)

                {

                    SetError(ERRCODE_IO_CANTREAD);

                    break;

                }

                m_pPipe->write(aBuffer.getConstArray(), sal_uInt32(nCount));

                nRead += m_pPipe->read();

                if (nCount < nRemain)

                {

                    m_xStream->closeInput();

                    m_pPipe->setEOF();

                    break;

                }

            }

        m_pPipe->clearReadBuffer();

    }

    return nRead;

}

// virtual

std::size_t SvInputStream::PutData(void const *, std::size_t)

{

    SetError(ERRCODE_IO_NOTSUPPORTED);

    return 0;

}

// virtual

void SvInputStream::FlushData()

{}

// virtual

sal_uInt64 SvInputStream::SeekPos(sal_uInt64 const nPos)

{

    // check if a truncated STREAM_SEEK_TO_END was passed

    assert(nPos != SAL_MAX_UINT32);

    if (open())

    {

        if (nPos == STREAM_SEEK_TO_END)

        {

            if (m_nSeekedFrom == STREAM_SEEK_TO_END)

            {

                if (m_xSeekable.is())

                    try

                    {

                        sal_Int64 nLength = m_xSeekable->getLength();

                        OSL_ASSERT(nLength >= 0);

                        if (o3tl::make_unsigned(nLength)

                            < STREAM_SEEK_TO_END)

                        {

                            m_nSeekedFrom = Tell();

                            return sal_uInt64(nLength);

                        }

                    }

                    catch (const io::IOException&)

                    {

                    }

                else

                    return Tell(); //@@@

            }

            else

                return Tell();

        }

        else if (nPos == m_nSeekedFrom)

        {

            m_nSeekedFrom = STREAM_SEEK_TO_END;

            return nPos;

        }

        else if (m_xSeekable.is())

        {

            try

            {

                m_xSeekable->seek(nPos);

                m_nSeekedFrom = STREAM_SEEK_TO_END;

                return nPos;

            }

            catch (const io::IOException&)

            {

            }

        }

        else if (m_pPipe->setReadPosition(nPos) == SvDataPipe_Impl::SEEK_OK)

        {

            m_nSeekedFrom = STREAM_SEEK_TO_END;

            return nPos;

        }

        else if ( nPos > Tell() )

        {

            // Read out the bytes

            sal_Int32 nRead = nPos - Tell();

            uno::Sequence< sal_Int8 > aBuffer;

            m_xStream->readBytes( aBuffer, nRead );

            return nPos;

        }

        else if ( nPos == Tell() )

            return nPos;

    }

    SetError(ERRCODE_IO_CANTSEEK);

    return Tell();

}

// virtual

void SvInputStream::SetSize(sal_uInt64)

{

    SetError(ERRCODE_IO_NOTSUPPORTED);

}

SvInputStream::SvInputStream( css::uno::Reference< css::io::XInputStream > xTheStream):

    m_xStream(std::move(xTheStream)),

    m_nSeekedFrom(STREAM_SEEK_TO_END)

{

    SetBufferSize(0);

}

// virtual

SvInputStream::~SvInputStream()

{

    if (m_xStream.is())

    {

        try

        {

            m_xStream->closeInput();

        }

        catch (const io::IOException&)

        {

        }

    }

}

//  SvOutputStream

// virtual

std::size_t SvOutputStream::GetData(void *, std::size_t)

{

    SetError(ERRCODE_IO_NOTSUPPORTED);

    return 0;

}

// virtual

std::size_t SvOutputStream::PutData(void const * pData, std::size_t nSize)

{

    if (!m_xStream.is())

    {

        SetError(ERRCODE_IO_CANTWRITE);

        return 0;

    }

    std::size_t nWritten = 0;

    for (;;)

    {

        sal_Int32 nRemain

            = sal_Int32(

                std::min(std::size_t(nSize - nWritten),

                         std::size_t(std::numeric_limits<sal_Int32>::max())));

        if (nRemain == 0)

            break;

        try

        {

            m_xStream->writeBytes(uno::Sequence< sal_Int8 >(

                                      static_cast<const sal_Int8 * >(pData)

                                          + nWritten,

                                      nRemain));

        }

        catch (const io::IOException&)

        {

            SetError(ERRCODE_IO_CANTWRITE);

            break;

        }

        nWritten += nRemain;

    }

    return nWritten;

}

// virtual

sal_uInt64 SvOutputStream::SeekPos(sal_uInt64)

{

    SetError(ERRCODE_IO_NOTSUPPORTED);

    return 0;

}

// virtual

void SvOutputStream::FlushData()

{

    if (!m_xStream.is())

    {

        SetError(ERRCODE_IO_INVALIDDEVICE);

        return;

    }

    try

    {

        m_xStream->flush();

    }

    catch (const io::IOException&)

    {

    }

}

// virtual

void SvOutputStream::SetSize(sal_uInt64)

{

    SetError(ERRCODE_IO_NOTSUPPORTED);

}

SvOutputStream::SvOutputStream(uno::Reference< io::XOutputStream > xTheStream):

    m_xStream(std::move(xTheStream))

{

    SetBufferSize(0);

}

// virtual

SvOutputStream::~SvOutputStream()

{

    if (m_xStream.is())

    {

        try

        {

            m_xStream->closeOutput();

        }

        catch (const io::IOException&)

        {

        }

    }

}

//  SvDataPipe_Impl

void SvDataPipe_Impl::remove(Page * pPage)

{

    if (

        pPage != m_pFirstPage ||

        m_pReadPage == m_pFirstPage ||

        (

         !m_aMarks.empty() &&

         *m_aMarks.begin() < m_pFirstPage->m_nOffset + m_nPageSize

        )

       )

    {

        return;

    }

    m_pFirstPage = m_pFirstPage->m_pNext;

    if (m_nPages <= 100) // min pages

        return;

    pPage->m_pPrev->m_pNext = pPage->m_pNext;

    pPage->m_pNext->m_pPrev = pPage->m_pPrev;

    std::free(pPage);

    --m_nPages;

}

SvDataPipe_Impl::~SvDataPipe_Impl()

{

    if (m_pFirstPage != nullptr)

        for (Page * pPage = m_pFirstPage;;)

        {

            Page * pNext = pPage->m_pNext;

            std::free(pPage);

            if (pNext == m_pFirstPage)

                break;

            pPage = pNext;

        }

}

sal_uInt32 SvDataPipe_Impl::read()

{

    if (m_pReadBuffer == nullptr || m_nReadBufferSize == 0 || m_pReadPage == nullptr)

        return 0;

    sal_uInt32 nSize = m_nReadBufferSize;

    sal_uInt32 nRemain = m_nReadBufferSize - m_nReadBufferFilled;

    m_pReadBuffer += m_nReadBufferFilled;

    m_nReadBufferSize -= m_nReadBufferFilled;

    m_nReadBufferFilled = 0;

    while (nRemain > 0)

    {

        sal_uInt32 nBlock = std::min(sal_uInt32(m_pReadPage->m_pEnd

                                                    - m_pReadPage->m_pRead),

                                     nRemain);

        memcpy(m_pReadBuffer, m_pReadPage->m_pRead, nBlock);

        m_pReadPage->m_pRead += nBlock;

        m_pReadBuffer += nBlock;

        m_nReadBufferSize -= nBlock;

        m_nReadBufferFilled = 0;

        nRemain -= nBlock;

        if (m_pReadPage == m_pWritePage)

            break;

        if (m_pReadPage->m_pRead == m_pReadPage->m_pEnd)

        {

            Page * pRemove = m_pReadPage;

            m_pReadPage = pRemove->m_pNext;

            remove(pRemove);

        }

    }

    return nSize - nRemain;

}

void SvDataPipe_Impl::write(sal_Int8 const * pBuffer, sal_uInt32 nSize)

{

    if (nSize == 0)

        return;

    if (m_pWritePage == nullptr)

    {

        m_pFirstPage

            = static_cast< Page * >(std::malloc(sizeof (Page)

                                           + m_nPageSize

                                           - 1));

        m_pFirstPage->m_pPrev = m_pFirstPage;

        m_pFirstPage->m_pNext = m_pFirstPage;

        m_pFirstPage->m_pStart = m_pFirstPage->m_aBuffer;

        m_pFirstPage->m_pRead = m_pFirstPage->m_aBuffer;

        m_pFirstPage->m_pEnd = m_pFirstPage->m_aBuffer;

        m_pFirstPage->m_nOffset = 0;

        m_pReadPage = m_pFirstPage;

        m_pWritePage = m_pFirstPage;

        ++m_nPages;

    }

    sal_uInt32 nRemain = nSize;

    if (m_pReadBuffer != nullptr && m_pReadPage == m_pWritePage

        && m_pReadPage->m_pRead == m_pWritePage->m_pEnd)

    {

        sal_uInt32 nBlock = std::min(nRemain,

                                     sal_uInt32(m_nReadBufferSize

                                                    - m_nReadBufferFilled));

        sal_uInt32 nPosition = m_pWritePage->m_nOffset

                                   + (m_pWritePage->m_pEnd

                                          - m_pWritePage->m_aBuffer);

        if (!m_aMarks.empty())

            nBlock = *m_aMarks.begin() > nPosition ?

                         std::min(nBlock, sal_uInt32(*m_aMarks.begin()

                                                         - nPosition)) :

                         0;

        if (nBlock > 0)

        {

            memcpy(m_pReadBuffer + m_nReadBufferFilled, pBuffer,

                           nBlock);

            m_nReadBufferFilled += nBlock;

            nRemain -= nBlock;

            nPosition += nBlock;

            m_pWritePage->m_nOffset = (nPosition / m_nPageSize) * m_nPageSize;

            m_pWritePage->m_pStart = m_pWritePage->m_aBuffer

                                         + nPosition % m_nPageSize;

            m_pWritePage->m_pRead = m_pWritePage->m_pStart;

            m_pWritePage->m_pEnd = m_pWritePage->m_pStart;

        }

    }

    if (nRemain <= 0)

        return;

    for (;;)

    {

        sal_uInt32 nBlock

            = std::min(sal_uInt32(m_pWritePage->m_aBuffer + m_nPageSize

                                      - m_pWritePage->m_pEnd),

                       nRemain);

        memcpy(m_pWritePage->m_pEnd, pBuffer, nBlock);

        m_pWritePage->m_pEnd += nBlock;

        pBuffer += nBlock;

        nRemain -= nBlock;

        if (nRemain == 0)

            break;

        if (m_pWritePage->m_pNext == m_pFirstPage)

        {

            if (m_nPages == std::numeric_limits< sal_uInt32 >::max())

                break;

            Page * pNew

                = static_cast< Page * >(std::malloc(

                                            sizeof (Page) + m_nPageSize

                                                - 1));

            assert(pNew && "Don't handle OOM conditions");

            pNew->m_pPrev = m_pWritePage;

            pNew->m_pNext = m_pWritePage->m_pNext;

            m_pWritePage->m_pNext->m_pPrev = pNew;

            m_pWritePage->m_pNext = pNew;

            ++m_nPages;

        }

        m_pWritePage->m_pNext->m_nOffset = m_pWritePage->m_nOffset

                                               + m_nPageSize;

        m_pWritePage = m_pWritePage->m_pNext;

        m_pWritePage->m_pStart = m_pWritePage->m_aBuffer;

        m_pWritePage->m_pRead = m_pWritePage->m_aBuffer;

        m_pWritePage->m_pEnd = m_pWritePage->m_aBuffer;

    }

}

SvDataPipe_Impl::SeekResult SvDataPipe_Impl::setReadPosition(sal_uInt32

                                                                 nPosition)

{

    if (m_pFirstPage == nullptr)

        return nPosition == 0 ? SEEK_OK : SEEK_PAST_END;

    if (nPosition

            <= m_pReadPage->m_nOffset

                   + (m_pReadPage->m_pRead - m_pReadPage->m_aBuffer))

    {

        if (nPosition

                < m_pFirstPage->m_nOffset

                      + (m_pFirstPage->m_pStart - m_pFirstPage->m_aBuffer))

            return SEEK_BEFORE_MARKED;

        while (nPosition < m_pReadPage->m_nOffset)

        {

            m_pReadPage->m_pRead = m_pReadPage->m_pStart;

            m_pReadPage = m_pReadPage->m_pPrev;

        }

    }

    else

    {

        if (nPosition

                > m_pWritePage->m_nOffset

                      + (m_pWritePage->m_pEnd - m_pWritePage->m_aBuffer))

            return SEEK_PAST_END;

        while (m_pReadPage != m_pWritePage

               && nPosition >= m_pReadPage->m_nOffset + m_nPageSize)

        {

            Page * pRemove = m_pReadPage;

            m_pReadPage = pRemove->m_pNext;

            remove(pRemove);

        }

    }

    m_pReadPage->m_pRead = m_pReadPage->m_aBuffer

                               + (nPosition - m_pReadPage->m_nOffset);

    return SEEK_OK;

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */