#ifndef PHOTOCOMPRESSARCHIVER_H
#define PHOTOCOMPRESSARCHIVER_H

#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

#include <boost/filesystem.hpp>
#include <boost/regex.hpp>

// Alias the boost fs namespace to keep the code readable
namespace bfs = boost::filesystem;

const std::string BOLD("\033[1m");
const std::string ENDC("\033[0m");
const std::string RED("\033[31m");
const std::string YELLOW("\033[33m");
const std::string PURPLE("\033[35m");

const std::string version("v0.1.0");

const boost::regex JPEG_REGEX("^.+\\.(jpg)|(jpeg)$", boost::regex::icase);
const boost::regex PJG_REGEX("^.+\\.pjg$", boost::regex::icase);

class PhotoCompressArchiver
{
    public:
    
        PhotoCompressArchiver(
                const std::string& path, 
                uint32_t num_cores,
                bool decompress,
                bool keep_orig,
                boost::regex& filter_regex);
        
        ~PhotoCompressArchiver();
        
        /**
         * Start processing
         */ 
        int execute();
        
        /**
         * Recursively find input files based on passed regex
         */ 
        void find_files(
            const bfs::path& dir_path, 
            const boost::regex& file_regex);
        
        /**
         * Fork and wait 
         */ 
        void fork_worker(uint32_t tid, std::vector<bfs::path>* file_sublist);
        
        /**
         * Calculate the return the "global" percent done as determined by the
         * m_files_processed and m_num_input_files instance variables.
         */ 
        double get_global_percent_done();
    
    private:
    
        const bfs::path m_path;             // top level path where to look for input files
        uint32_t m_num_cores;               // number of cores on the machine
        bool m_decompress;                  // decompress files instead of compress them
        bool m_keep_orig;                   // keep; don't delete original files
        
        std::mutex m_output_mutex;          // output mutex
        
        std::atomic<uint32_t> m_files_processed;        // number of input files processed
        uint32_t m_num_input_files;                     // total number of input files found
        std::atomic<uint64_t> m_total_uncompressed_size;// total uncompressed size of all images
        std::atomic<uint64_t> m_total_compressed_size;  // total compressed size of all images
        
        std::vector<bfs::path> m_file_list;     // input file list (either images or compressed images)
        
        std::thread* p_finder_thread;                   // file finder thread
        std::vector<std::thread*> m_worker_threads;     // worker threads
        
        bool m_filter_empty;                    // is the filter regex empty
        boost::regex& m_filter_regex;           // filter regular expression
};

#endif // PHOTOCOMPRESSARCHIVER_H