/**
 ** Copyright (c) 2007-2009 Illumina, Inc.
 **
 ** This software is covered by the "Illumina Genome Analyzer Software
 ** License Agreement" and the "Illumina Source Code License Agreement",
 ** and certain third party copyright/licenses, and any user of this
 ** source file is bound by the terms therein (see accompanying files
 ** Illumina_Genome_Analyzer_Software_License_Agreement.pdf and
 ** Illumina_Source_Code_License_Agreement.pdf and third party
 ** copyright/license notices).
 **
 ** This file is part of the Consensus Assessment of Sequence And VAriation
 ** (CASAVA) software package.
 **
 ** \file BclToFastqDemultiplexer.hh
 **
 ** \brief Top level library component to demultiplex a tile stack of bcl files.
 **
 ** \author Roman Petrovski
 **/

#ifndef CASAVA_DEMULTIPLEX_BCL_TO_FASTQ_DEMULTIPLEXER_HH
#define CASAVA_DEMULTIPLEX_BCL_TO_FASTQ_DEMULTIPLEXER_HH

#include "demultiplex/MultiFileFastqWriter.hh"
#include "demultiplex/CompositeBclReader.hh"

#include "BclDemultiplexer.hh"
#include "DemuxSummaryCollector.hh"

namespace casava
{
namespace demultiplex
{

namespace fs = boost::filesystem;
namespace cc = casava::common;
namespace cio = casava::io;

class BclToFastqDemultiplexer : public BclDemultiplexer
{
public:

    BclToFastqDemultiplexer(const std::string &instrumentName,
                     const unsigned int runNumber,
                     const std::string &flowCellId,
                     const unsigned int lane,
                     const std::vector<unsigned int> tiles,
                     const std::vector<std::vector<unsigned int> > &readCycles,
                     const std::vector<unsigned int> &inputReadNumbers,
                     const std::vector<unsigned int> &outputReadNumbers,
                     const std::vector<unsigned int> &barcodeCycles,
                     const BarcodeTranslationTable &barcodeDirectories,
                     const fs::path &basecallsPath,
                     const std::string &outputFormat,
                     const unsigned int fastqClusterCount,
                     const bool createMissingFolders,
                     const bool createDemuxIndex,
                     const fs::path &intensitiesPath,
                     const fs::path &inputPositionsDir,
                     const std::string &inputPositionsFileType,
                     const fs::path &inputFilterDir,
                     const bool filterPerRead,
                     const bool needSeparateControls,
                     const cc::Compression &compressor,
                     const fs::path &outputSummaryFilePath,
                     const bool withEamss,
                     const bool ignoreMissingBcl,
                     const bool ignoreMissingCtrl,
                     const bool withFailedReads,
                     const std::vector<std::string> &readAdapterSequences)
    : BclDemultiplexer(instrumentName, runNumber, flowCellId, lane, tiles, readCycles,
            barcodeCycles, barcodeDirectories, basecallsPath, outputFormat,
            fastqClusterCount, createMissingFolders, createDemuxIndex,
            intensitiesPath, inputPositionsDir, inputPositionsFileType, inputFilterDir,
            compressor)
    , inputReadNumbers_(inputReadNumbers)
    , outputReadNumbers_(outputReadNumbers)
    , outputSummaryFilePath_(outputSummaryFilePath)
    , ignoreMissingBcl_(ignoreMissingBcl)
    , ignoreMissingCtrl_(ignoreMissingCtrl)
    , filterPerRead_(filterPerRead)
    , needSeparateControls_(needSeparateControls)
    , withEamss_(withEamss)
    , withFailedReads_(withFailedReads)
    , readAdapterSequences_(readAdapterSequences)
    {
    }

    void run() const;
private:
    const std::vector<unsigned int> inputReadNumbers_;
    const std::vector<unsigned int> outputReadNumbers_;
    const fs::path outputSummaryFilePath_;
    const bool ignoreMissingBcl_;
    const bool ignoreMissingCtrl_;
    const bool filterPerRead_;
    const bool needSeparateControls_;
    const bool withEamss_;
    const bool withFailedReads_;
    const std::vector<std::string> readAdapterSequences_;
    boost::shared_ptr<CompositeBclReader> createReader(
                                                const unsigned int tile,
                                                const size_t readIndex,
                                                const std::vector<unsigned int> &cycles) const;
    boost::shared_ptr<DemuxSummaryCollector<MultiFileWriter> > createMultiFileWriter(
                                                const SamplePath &samplePath,
                                                const unsigned int readNumber) const;

    BclToFastqDemultiplexer();
    BclToFastqDemultiplexer(const BclToFastqDemultiplexer &);
    BclToFastqDemultiplexer &operator=(const BclToFastqDemultiplexer &);
};

} // namespave demultiplex
} // namespace casava


#endif // CASAVA_DEMULTIPLEX_BCL_TO_FASTQ_DEMULTIPLEXER_HH