#ifndef IPLIMIT_H
#define IPLIMIT_H



#include <boost/config.hpp>
#include <algorithm>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/managed_mapped_file.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>

#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/identity.hpp>
#include <iterator>
#include <string>
#include <iostream>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/interprocess/sync/named_recursive_mutex.hpp>

#include <vector>
#include <pthread.h>

namespace IPRateLimit
{

using boost::multi_index_container;
using namespace boost::multi_index;
namespace bip=boost::interprocess;


typedef bip::managed_mapped_file::allocator<char>::type	char_allocator;
typedef bip::basic_string<char, std::char_traits<char>, char_allocator> shm_string;




struct iprate
{
    uint32_t ip;
    uint32_t countSec;
    uint32_t countMin;
    uint32_t countHour;
    uint32_t countDay;
    time_t   tmSec;
    time_t   tmMin;
    time_t   tmHour;
    time_t   tmDay;
    iprate()
    {
        ip = countSec = countMin = countHour = countDay = tmSec = tmMin = tmHour = tmDay = 0;
    }
};


typedef multi_index_container<
iprate,indexed_by<
hashed_unique<BOOST_MULTI_INDEX_MEMBER(iprate,uint32_t,ip)>,
ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(iprate,uint32_t,countSec)>,
ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(iprate,uint32_t,countMin)>,
ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(iprate,uint32_t,countHour)>,
ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(iprate,uint32_t,countDay)>
>,
bip::allocator<iprate,bip::managed_mapped_file::segment_manager>
> iprate_con;

typedef boost::multi_index::nth_index<iprate_con,0>::type ipIdx;
typedef boost::multi_index::nth_index<iprate_con,1>::type secCountIdx;
typedef boost::multi_index::nth_index<iprate_con,2>::type minCountIdx;
typedef boost::multi_index::nth_index<iprate_con,3>::type hourCountIdx;
typedef boost::multi_index::nth_index<iprate_con,4>::type dayCountIdx;

enum ENUM_TYPE
{
EIP=0,ESEC_COUNT=1,EMIN_COUNT=2,EHOUR_COUNT=3,EDAY_COUNT=4
};


class CIPLimit
{
public:
    CIPLimit(const char *shm_name,const  long count);
    ~CIPLimit();
    int init();
    int incCount(uint32_t ip,iprate &data);
    int getDataGreaterThan(int minNum,const ENUM_TYPE etype,std::vector<iprate> &data);

    /*bool lock();
    void unlock();
    int destroyMutex();*/

	

public:
    static uint32_t IPStr2Int(const char* pStr);
    static void IPInt2Str(uint32_t ip,char *pIP);
    static void time2str(time_t t,std::string &str);

private:
    int getSecCountGreaterThan(int minNum,std::vector<iprate> &data);
    int getMinCountGreaterThan(int minNum,std::vector<iprate> &data);
    int getHourCountGreaterThan(int minNum,std::vector<iprate> &data);
    int getDayCountGreaterThan(int minNum,std::vector<iprate> &data);
protected:
private:

    iprate_con *con;
    bip::named_recursive_mutex m_mutex;
    bip::managed_mapped_file m_seg;
    int maxCount;
};
}
#endif // IPLIMIT_H