/*
 * Copyright 2008, Salvatore Benedetto, salvatore.benedetto@gmail.com
 * Copyright 2003, Tyler Dauwalder, tyler@dauwalder.net.
 * Distributed under the terms of the MIT License.
 */

#ifndef _UDF_ALLOCATION_DESCRIPTOR_LIST_H
#define _UDF_ALLOCATION_DESCRIPTOR_LIST_H

/*! \file AllocationDescriptorList.h */

#include "UdfDebug.h"

#include "Icb.h"
#include "UdfStructures.h"
#include "Volume.h"

#include <util/kernel_cpp.h>

/*!     \brief Common interface for dealing with the three standard
        forms of allocation descriptors used in UDF icbs.

        The \c Accessor class is an allocation descriptor accessor class
        for the allocation scheme of interest. Instances of it should be
        passable by     value, and should define the following public members:
        - typedef DescriptorType;
        - inline uint8 GetType(DescriptorType &descriptor);
        - inline uint32 GetBlock(DescriptorType &descriptor);
        - inline uint16 GetPartition(DescriptorType &descriptor);
        - inline uint32 GetLength(DescriptorType &descriptor);
*/
template <class Accessor>
class AllocationDescriptorList {
private:
        typedef typename Accessor::DescriptorType Descriptor;

public:
                                                        AllocationDescriptorList(Icb *icb,
                                                                Accessor accessor = Accessor());

        status_t                                FindExtent(off_t start, long_address *extent,
                                                                bool *isEmpty);

private:

        off_t                                   _BlockIndex() const { return fBlockIndex; }
        Descriptor                              *_CurrentDescriptor() const;
        Descriptor                              *_DescriptorArray() const;
        size_t                                  _DescriptorArraySize() const;
        int32                                   _DescriptorIndex() const { return fDescriptorIndex; }
        int32                                   _DescriptorNumber() const { return fDescriptorNumber; }
        status_t                                _MoveToNextDescriptor();
        void                                    _Rewind();
        void                                    _WalkContinuationChain(Descriptor *descriptor);

        Accessor                                fAccessor;
        CachedBlock                             fAdditionalDescriptors;
        off_t                                   fBlockIndex;
        int32                                   fDescriptorIndex;
        int32                                   fDescriptorNumber;
        Icb                                             *fIcb;
        Descriptor                              *fIcbDescriptors;
        int32                                   fIcbDescriptorsSize;
        bool                                    fReadFromIcb;
        Volume                                  *fVolume;
};


template<class Accessor>
AllocationDescriptorList<Accessor>::AllocationDescriptorList(Icb *icb,
        Accessor accessor)
                :
                fAccessor(accessor),
                fAdditionalDescriptors(icb->GetVolume()),
                fBlockIndex(0),
                fDescriptorIndex(0),
                fDescriptorNumber(0),
                fIcb(icb),
                fIcbDescriptors((Descriptor *)icb->AllocationDescriptors()),
                fIcbDescriptorsSize(icb->AllocationDescriptorsSize()),
                fReadFromIcb(true),
                fVolume(icb->GetVolume())
{
        TRACE(("AllocationDescriptorList<>::AllocationDescriptorList\n"));
        _WalkContinuationChain(_CurrentDescriptor());
}


/*! \brief Finds the extent for the given address in the stream,
        returning it in the address pointed to by \a blockRun.

        \param start The byte address of interest
        \param extent The extent containing the stream address given
                        by \c start.
        \param isEmpty If set to true, indicates that the given extent is
                        unrecorded  and thus its contents should be interpreted
                        as all zeros.
*/
template<class Accessor>
status_t
AllocationDescriptorList<Accessor>::FindExtent(off_t start,
        long_address *extent, bool *isEmpty)
{
        TRACE(("AllocationDescriptorList<>::FindExtent: start: %" B_PRIdOFF ", "
                "extent: %p, isEmpty: %p\n", start, extent, isEmpty));

        off_t startBlock = start >> fVolume->BlockShift();

        // This should never have to happen, as FindExtent is only called by
        // Icb::_Read() sequentially, as a file read is performed, but you
        // never know. :-)
        if (startBlock < _BlockIndex())
                _Rewind();

        status_t status = B_OK;
        while (true) {
                Descriptor *descriptor = _CurrentDescriptor();
                if (descriptor) {
                        if (_BlockIndex() <= startBlock && startBlock
                                < _BlockIndex() + fAccessor.GetLength(*descriptor)) {
                                // The start block is somewhere in this extent, so return
                                // the applicable tail end portion.
                                off_t offset = startBlock - _BlockIndex();
                                extent->set_block(fAccessor.GetBlock(*descriptor) + offset);
                                extent->set_partition(fAccessor.GetPartition(*descriptor));
                                extent->set_length(fAccessor.GetLength(*descriptor)
                                        - (offset*fVolume->BlockSize()));
                                extent->set_type(fAccessor.GetType(*descriptor));
                                break;
                        } else {
                                _MoveToNextDescriptor();
                        }
                } else {
                        TRACE_ERROR(("AllocationDescriptorList<>::FindExtent: "
                                "Descriptor #%" B_PRId32 " found NULL\n",
                                _DescriptorNumber()));
                        status = B_ERROR;
                        break;
                }
        }

        return status;
}


//      #pragma - Private methods


template<class Accessor>
typename AllocationDescriptorList<Accessor>::Descriptor*
AllocationDescriptorList<Accessor>::_CurrentDescriptor() const
{
        TRACE(("AllocationDescriptorList<>::_CurrentDescriptor:\n"
                "\t_DescriptorIndex() + 1 * sizeof(Descriptor) = %ld\n"
                "\t_DescriptorArraySize() = %ld\n"
                "\t_DescriptorArray() = %p\n",
                (_DescriptorIndex() + 1) * sizeof(Descriptor),
                _DescriptorArraySize(), _DescriptorArray()));

        return ((_DescriptorIndex() + 1) * sizeof(Descriptor)
                <= _DescriptorArraySize())
                ? &(_DescriptorArray()[_DescriptorIndex()])
                : NULL;
}


template<class Accessor>
status_t
AllocationDescriptorList<Accessor>::_MoveToNextDescriptor()
{
        Descriptor* descriptor = _CurrentDescriptor();
        if (!descriptor)
                return B_ENTRY_NOT_FOUND;

        // Increment our indices and get the next descriptor
        // from this extent.
        fBlockIndex += fAccessor.GetLength(*descriptor);
        fDescriptorIndex++;
        fDescriptorNumber++;
        descriptor = _CurrentDescriptor();

        // If no such descriptor exists, we've run out of
        // descriptors in this extent, and we're done. The
        // next time _CurrentDescriptor() is called, it will
        // return NULL, signifying this. Otherwise, we have to
        // see if the new descriptor identifies the next extent
        // of allocation descriptors, in which case we have to
        // load up the appropriate extent (guaranteed to be at
        // most one block in length by UDF-2.01 5.1 and UDF-2.01
        // 2.3.11).
        _WalkContinuationChain(descriptor);

        return B_ERROR;
}


template<class Accessor>
void
AllocationDescriptorList<Accessor>::_WalkContinuationChain(Descriptor *descriptor)
{
        TRACE(("AllocationDescriptorList<>::_WalkContinuationChain: descriptor = %p\n",
                descriptor));
        if (descriptor
                && fAccessor.GetType(*descriptor) == EXTENT_TYPE_CONTINUATION) {
                // Load the new block, make sure we're not trying
                // to read from the icb descriptors anymore, and
                // reset the descriptor index.
                fAdditionalDescriptors.SetTo(fAccessor, *descriptor);
                fReadFromIcb = false;
                fDescriptorIndex = 0;

                // Make sure that the first descriptor in this extent isn't
                // another continuation. That would be stupid, but not
                // technically illegal.
                _WalkContinuationChain(_CurrentDescriptor());
        }
}


template<class Accessor>
void
AllocationDescriptorList<Accessor>::_Rewind()
{
        fDescriptorIndex = 0;
        fDescriptorNumber = 0;
        fReadFromIcb = true;
}


template<class Accessor>
typename AllocationDescriptorList<Accessor>::Descriptor*
AllocationDescriptorList<Accessor>::_DescriptorArray() const
{
        return fReadFromIcb ? fIcbDescriptors
                : (typename AllocationDescriptorList<Accessor>::Descriptor *)
                        fAdditionalDescriptors.Block();
}


template<class Accessor>
size_t
AllocationDescriptorList<Accessor>::_DescriptorArraySize() const
{
        return fReadFromIcb ? fIcbDescriptorsSize
                : fAdditionalDescriptors.BlockSize();
}


//      pragma - Accessors


class ShortDescriptorAccessor {
public:
        ShortDescriptorAccessor(uint16 partition)
                :
                fPartition(partition)
        {
        }

        typedef short_address DescriptorType;

        inline uint32 GetBlock(DescriptorType &descriptor) const
        {
                return descriptor.block();
        }

        inline uint32 GetLength(DescriptorType &descriptor) const
        {
                return descriptor.length();
        }

        inline uint16 GetPartition(DescriptorType &descriptor) const
        {
                return fPartition;
        }

        inline uint8 GetType(DescriptorType &descriptor) const
        {
                return descriptor.type();
        }

private:
        uint16                  fPartition;
};


class LongDescriptorAccessor {
public:
        typedef long_address DescriptorType;

        inline uint32 GetBlock(DescriptorType &descriptor) const
        {
                return descriptor.block();
        }

        inline uint32 GetLength(DescriptorType &descriptor) const
        {
                return descriptor.length();
        }

        inline uint16 GetPartition(DescriptorType &descriptor) const
        {
                return descriptor.partition();
        }

        inline uint8 GetType(DescriptorType &descriptor) const
        {
                return descriptor.type();
        }
};

#endif  // _UDF_ALLOCATION_DESCRIPTOR_LIST_H