/**
 ** 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 TilePaths.hh
 **
 ** \brief Helper for run folder tile path formatting.
 **
 ** \author Roman Petrovski
 **/

#ifndef CASAVA_DEMULTIPLEX_LANE_PATHS_HH
#define CASAVA_DEMULTIPLEX_LANE_PATHS_HH

#include <boost/format.hpp>
#include <boost/filesystem.hpp>
#include <boost/throw_exception.hpp>

namespace casava
{
namespace demultiplex

{

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

class LanePaths
{
public:
    LanePaths(const unsigned int lane, const fs::path intensitiesDir, const fs::path basecallsDir)
        : lane_(lane), intensitiesDir_(intensitiesDir), basecallsDir_(basecallsDir), rtaHierarchy_(false)
        {}
    LanePaths(const unsigned int lane, const fs::path intensitiesDir, const bool rta)
        : lane_(lane), intensitiesDir_(intensitiesDir), rtaHierarchy_(rta)
        {}
    LanePaths(const unsigned int lane, const bool rta, const fs::path basecallsDir)
        : lane_(lane), basecallsDir_(basecallsDir), rtaHierarchy_(rta)
        {}

  // Directories:
    const std::string formatIntensitiesDirName() const
        {return std::string("Intensities");}
    const std::string formatBaseCallsDirName() const
        {return std::string("BaseCalls");}
    const std::string formatLaneDirName() const
        {return (boost::format("L%03u") % lane_).str();}
    const std::string formatCycleDirName(const unsigned int cycle) const
        {return (boost::format("C%u.1") % cycle).str();}

    const fs::path formatLanePath(const fs::path &path) const
        {return path / formatLaneDirName();}
    const fs::path formatCyclePath(const fs::path &path, const unsigned int cycle) const
        {return path / formatCycleDirName(cycle);}

    const fs::path formatIntensitiesPath() const
        {return intensitiesDir_.empty()
              ? (rtaHierarchy_ ? basecallsDir_ / ".." : "..")
              : intensitiesDir_;}

    const fs::path formatBaseCallsPath() const
        {return basecallsDir_.empty()
              ? (rtaHierarchy_ ? intensitiesDir_ / formatBaseCallsDirName() : ".")
              : basecallsDir_;}

    const fs::path formatBaseCallsLanePath() const
        {return formatLanePath(formatBaseCallsPath());}
    const fs::path formatIntensitiesLanePath() const
        {return formatLanePath(formatIntensitiesPath());}

    const fs::path formatBaseCallsCyclePath(const unsigned int cycle) const
        {return formatCyclePath(formatBaseCallsLanePath(),cycle);}
    const fs::path formatIntensitiesCyclePath(const unsigned int cycle) const
        {return formatCyclePath(formatIntensitiesLanePath(),cycle);}

    const fs::path formatBclFilePath(const unsigned int tile, const unsigned int cycle) const
        {return formatBaseCallsCyclePath(cycle) / formatBclFileName(tile);}
    const fs::path formatBclFilePath(const fs::path baseCalls, const unsigned int tile, const unsigned int cycle) const
        {return formatCyclePath(baseCalls,cycle) / formatBclFileName(tile);}

    const fs::path formatStatsFilePath(const unsigned int tile, const unsigned int cycle) const
        {return formatBaseCallsCyclePath(cycle) / formatStatsFileName(tile);}
    const fs::path formatStatsFilePath(const fs::path baseCalls, const unsigned int tile, const unsigned int cycle) const
        {return formatCyclePath(baseCalls,cycle) / formatStatsFileName(tile);}

    const fs::path formatFiltersFilePath(const fs::path filterDir, const std::string filterFile) const
        {return formatFiltersPath(filterDir) / filterFile;}
    const fs::path formatFiltersFilePath(const fs::path filterDir, const unsigned int tile) const
        {return formatFiltersFilePath(filterDir, formatFiltersFileName(tile));}
    const fs::path formatFiltersFilePath(const fs::path filterDir, const unsigned int tile, const unsigned int readNumber) const
        {return formatFiltersFilePath(filterDir, formatFiltersFileName(tile, readNumber));}

    const fs::path formatControlsFilePath(const fs::path controlDir, const std::string controlFile) const
        {return formatFiltersPath(controlDir) / controlFile;}
    const fs::path formatControlsFilePath(const fs::path controlDir, const unsigned int tile) const
        {return formatFiltersFilePath(controlDir, formatControlsFileName(tile));}
    const fs::path formatControlsFilePath(const fs::path controlDir, const unsigned int tile, const unsigned int readNumber) const
        {return formatFiltersFilePath(controlDir, formatControlsFileName(tile, readNumber));}

    const fs::path formatPositionsFilePath(const fs::path positionsDir, const std::string positionsFile) const
        {return formatPositionsPath(positionsDir) / positionsFile;}
    const fs::path formatPositionsFilePath(const fs::path positionsDir, const unsigned int tile, const std::string positionsFileType) const
        {return formatPositionsFilePath(positionsDir, formatPositionsFileName(getPositionsFileNameTemplate(positionsFileType), tile));}
    const fs::path formatPosFilePath(const fs::path &positionsDir, const unsigned int tile) const
        {return formatPositionsFilePath(positionsDir, tile, getPosFileType());}

  // Files:
    static std::string formatBclFileName(const unsigned int lane, const unsigned int tile)
        {return (boost::format("s_%d_%d.bcl") % lane % tile).str();}
    const std::string formatBclFileName(const unsigned int tile) const
         {return formatBclFileName(lane_, tile);}

    static std::string formatStatsFileName(const unsigned int lane, const unsigned int tile)
        {return (boost::format("s_%d_%d.stats") % lane % tile).str();}
    const std::string formatStatsFileName(const unsigned int tile) const
        {return formatStatsFileName(lane_, tile);}

    const std::string formatFiltersFileName(const unsigned int tile) const
        {return (boost::format("s_%u_%04u.filter") % lane_ % tile).str();}
    const std::string formatFiltersFileName(const unsigned int tile, const unsigned int readNumber) const
        {return (boost::format("s_%u_%u_%04u.filter") % lane_ % readNumber % tile).str();}

    const std::string formatControlsFileName(const unsigned int tile) const
        {return (boost::format("s_%u_%04u.control") % lane_ % tile).str();}
    const std::string formatControlsFileName(const unsigned int tile, const unsigned int readNumber) const
        {return (boost::format("s_%u_%u_%04u.control") % lane_ % readNumber % tile).str();}

    const std::string formatPosFileName(const unsigned int tile) const
        {return formatPositionsFileName(getPosFileNameTemplate(), tile);}
    const std::string formatPositionsFileName(const std::string &posFileTemplate, const unsigned int tile) const
        {return (boost::format(posFileTemplate) % lane_ % tile).str();}

  // Templates:
    static const std::string getPosFileNameTemplate()
        {const static std::string tmplt("s_%u_%04u_pos.txt"); return tmplt;}

    static const std::string getLocsFileNameTemplate()
        {const static std::string tmplt("s_%u_%u.locs"); return tmplt;}

    static const std::string getClocsFileNameTemplate()
        {const static std::string tmplt("s_%u_%u.clocs"); return tmplt;}

    static const char *getPosFileType()
        {return "_pos.txt";}

    static const char *getLocsFileType()
        {return ".locs";}

    static const char *getClocsFileType()
        {return ".clocs";}

    static const std::string getPositionsFileNameTemplate(const std::string& positionsFileType) {
        if (getPosFileType() == positionsFileType) return getPosFileNameTemplate();
        if (getLocsFileType() == positionsFileType) return getLocsFileNameTemplate();
        if (getClocsFileType() == positionsFileType) return getClocsFileNameTemplate();
        BOOST_THROW_EXCEPTION(cc::InvalidParameterException("Positions file type must be '*_pos.txt', '*.locs' or '*.clocs'"));
    }

  // Demultiplexing:
    const std::string formatFastqFileName(const std::string sample,
                                          const std::string barcode,
                                          const unsigned int readNumber) const
        {return sample + "_" + barcode + "_" + (boost::format("L%03u_R%u_%%03u.fastq") % lane_ % readNumber).str();}

    const fs::path formatFastqPath(const fs::path intensitiesPath) const
        {return intensitiesPath;}

    const fs::path formatDemuxIndexFilePath(const fs::path intensitiesPath, const unsigned int tile) const
        {return formatDemuxIndexPath(intensitiesPath) / formatDemuxIndexFileName(tile);}
    const std::string formatDemuxIndexFileName(const unsigned int tile) const
        {return (boost::format("s_%u_%04u_demux_index.txt") % lane_ %tile).str();}
    const fs::path formatDemuxIndexPath(const fs::path intensitiesPath) const
        {return intensitiesPath;}

private:
    const unsigned int lane_;
    const fs::path intensitiesDir_;
    const fs::path basecallsDir_;
    const bool rtaHierarchy_;  // whether Intensities/BaseCalls are tied in by the RTA hierarchy
                               //    true => parent/child relationship
                               //   false => assume CWD is BaseCalls

    const fs::path formatFiltersPath(const fs::path filterDir) const
        {return filterDir.empty() ? formatBaseCallsLanePath() : filterDir;}
    const fs::path formatPositionsPath(const fs::path positionsDir) const
        {return positionsDir.empty() ? formatIntensitiesLanePath() : positionsDir;}

};

} // namespave demultiplex
} // namespace casava


#endif // CASAVA_DEMULTIPLEX_LANE_PATHS_HH