// Copyright (C) 2003  Davis E. King (davis@dlib.net)
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_TEST_CONDITIONING_CLASs_H_
#define DLIB_TEST_CONDITIONING_CLASs_H_


#include <string>
#include <ctime>
#include <cstdlib>

#include <dlib/conditioning_class.h>

#include "tester.h"

namespace  
{

    using namespace test;
    using namespace dlib;

    logger dlog("test.conditioning_class");

    template <
        typename cc,
        typename cc2
        >
    void conditioning_class_kernel_test (
    )
    /*!
        requires
            - cc is an implementation of conditioning_class/conditioning_class_kernel_abstract.h            
              the alphabet_size for cc is 256
            - cc2 is an implementation of conditioning_class/conditioning_class_kernel_abstract.h            
              the alphabet_size for cc2 is 2
        ensures
            - runs tests on cc for compliance with the specs 
    !*/
    {        

        srand(static_cast<unsigned int>(time(0)));



        typename cc::global_state_type gs;
        typename cc2::global_state_type gs2;




        for (int g = 0; g < 2; ++g)
        {
            print_spinner();
            unsigned long amount=g+1;
            cc2 test(gs2);
            cc2 test2(gs2);


            DLIB_TEST(test.get_memory_usage() != 0);

            const unsigned long alphabet_size = 2;                


            DLIB_TEST(test.get_total() == 1);

            DLIB_TEST(test.get_count(alphabet_size-1)==1);
            for (unsigned long i = 0; i < alphabet_size-1; ++i)
            {
                unsigned long low_count, high_count, total_count;
                DLIB_TEST_MSG(test.get_range(i,low_count,high_count,total_count) == 0,i);
                DLIB_TEST(test.get_count(i) == 0);
                DLIB_TEST(test.get_total() == 1);
            }



            for (unsigned long i = 0; i < alphabet_size; ++i)
            {
                test.increment_count(i,static_cast<unsigned short>(amount));
                unsigned long low_count = 0, high_count = 0, total_count = 0;

                if (i ==alphabet_size-1)
                {
                    DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == 1+amount);

                    DLIB_TEST(high_count == low_count+1+amount);
                    DLIB_TEST(total_count == test.get_total());


                    DLIB_TEST(test.get_count(i) == 1+amount);
                }
                else
                {
                    DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == amount);

                    DLIB_TEST(high_count == low_count+amount);
                    DLIB_TEST(total_count == test.get_total());


                    DLIB_TEST(test.get_count(i) == amount);
                }
                DLIB_TEST(test.get_total() == (i+1)*amount + 1);
            } 


            for (unsigned long i = 0; i < alphabet_size; ++i)
            {                
                unsigned long temp = static_cast<unsigned long>(::rand()%40);
                for (unsigned long j = 0; j < temp; ++j)
                {
                    test.increment_count(i,static_cast<unsigned short>(amount));
                    if (i == alphabet_size-1)
                    {
                        DLIB_TEST(test.get_count(i) == (j+1)*amount + 1 + amount);                    
                    }
                    else
                    {
                        DLIB_TEST(test.get_count(i) == (j+1)*amount + amount);                    
                    }
                }

                unsigned long target = test.get_total()/2;
                unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;

                if (i == alphabet_size-1)
                {
                    DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==temp*amount+1+amount);
                    DLIB_TEST(high_count-low_count == temp*amount+1+amount);
                }
                else
                {
                    DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==temp*amount + amount);
                    DLIB_TEST(high_count-low_count == temp*amount + amount);
                }
                DLIB_TEST(total_count == test.get_total());

                test.get_symbol(target,symbol,low_count,high_count);
                DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                DLIB_TEST(low_count <= target);
                DLIB_TEST(target < high_count);
                DLIB_TEST(high_count <= test.get_total());

            }

            test.clear();


            for (unsigned long i = 0; i < alphabet_size-1; ++i)
            {
                test.increment_count(i);
                unsigned long low_count = 0, high_count = 0, total_count = 0;
                DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == 1);

                DLIB_TEST(high_count == low_count+1);
                DLIB_TEST(total_count == test.get_total());

                DLIB_TEST(test.get_count(i) == 1);
                DLIB_TEST(test.get_total() == i+2);
            } 




            unsigned long counts[alphabet_size];


            print_spinner();
            for (int k = 0; k < 10; ++k)
            {
                unsigned long range = ::rand()%50000 + 2;

                test.clear();

                for (unsigned long i = 0; i < alphabet_size-1; ++i)
                    counts[i] = 0;
                unsigned long total = 1;
                counts[alphabet_size-1] = 1;


                for (unsigned long i = 0; i < alphabet_size; ++i)
                {                
                    unsigned long temp = static_cast<unsigned long>(::rand()%range);
                    for (unsigned long j = 0; j < temp; ++j)
                    {
                        test.increment_count(i);  


                        if (total >= 65535)
                        {
                            total = 0;
                            for (unsigned long i = 0; i < alphabet_size; ++i)
                            {
                                counts[i] >>= 1;
                                total += counts[i];
                            }
                            if (counts[alphabet_size-1]==0)
                            {
                                counts[alphabet_size-1] = 1;
                                ++total;
                            }
                        }
                        counts[i] = counts[i] + 1;
                        ++total;


                    }


                    unsigned long temp_total = 0;
                    for (unsigned long a = 0; a < alphabet_size; ++a)
                    {
                        temp_total += test.get_count(a);
                    }
                    DLIB_TEST_MSG(temp_total == test.get_total(),
                                 "temp_total == " << temp_total << std::endl <<
                                 "test.get_total() == " << test.get_total()
                    );

                    DLIB_TEST(test.get_count(alphabet_size-1) == counts[alphabet_size-1]);
                    DLIB_TEST_MSG(test.get_total() == total,
                                 "test.get_total() == " << test.get_total() << std::endl <<
                                 "total == " << total
                    );

                    unsigned long target = test.get_total()/2;
                    unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;


                    DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==counts[symbol]);

                    if (counts[symbol] != 0)
                    {
                        DLIB_TEST(total_count == total);

                        DLIB_TEST(high_count <= total);
                        DLIB_TEST(low_count < high_count);
                        DLIB_TEST(high_count <= test.get_total());
                        DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                    }


                    if (target < total)
                    {
                        test.get_symbol(target,symbol,low_count,high_count);


                        DLIB_TEST(high_count <= total);
                        DLIB_TEST(low_count < high_count);
                        DLIB_TEST(high_count <= test.get_total());
                        DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                        DLIB_TEST(test.get_count(symbol) == counts[symbol]);
                    }




                }

            }

            print_spinner();

            for (unsigned long h = 0; h < 10; ++h)
            {
                test.clear();
                DLIB_TEST(test.get_total() == 1);

                // fill out test with some numbers
                unsigned long temp = ::rand()%30000 + 50000;
                for (unsigned long j = 0; j < temp; ++j)
                {
                    unsigned long symbol = (unsigned long)::rand()%alphabet_size;
                    test.increment_count(symbol);                    
                }

                // make sure all symbols have a count of at least one
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {   
                    if (test.get_count(j) == 0)
                        test.increment_count(j);
                }

                unsigned long temp_total = 0;
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {
                    temp_total += test.get_count(j);
                }
                DLIB_TEST(temp_total == test.get_total());


                unsigned long low_counts[alphabet_size];
                unsigned long high_counts[alphabet_size];
                // iterate over all the symbols
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {
                    unsigned long total;
                    unsigned long count = test.get_range(j,low_counts[j],high_counts[j],total);
                    DLIB_TEST(count == test.get_count(j));
                    DLIB_TEST(count == high_counts[j] - low_counts[j]);

                }


                // make sure get_symbol() matches what get_range() told us
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {                    
                    for (unsigned long k = low_counts[j]; k < high_counts[j]; ++k)
                    {
                        unsigned long symbol, low_count, high_count;
                        test.get_symbol(k,symbol,low_count,high_count);
                        DLIB_TEST(high_count - low_count == test.get_count(symbol));
                        DLIB_TEST_MSG(j == symbol,
                                     "j == " << j << std::endl <<
                                     "k == " << k << std::endl <<
                                     "symbol == " << symbol << std::endl <<
                                     "low_counts[j] == " << low_counts[j] << std::endl <<
                                     "high_counts[j] == " << high_counts[j] << std::endl <<
                                     "low_counts[symbol] == " << low_counts[symbol] << std::endl <<
                                     "high_counts[symbol] == " << high_counts[symbol] << std::endl << 
                                     "low_count == " << low_count << std::endl << 
                                     "high_count == " << high_count << std::endl << 
                                     "temp.count(j) == " << test.get_count(j)
                        );
                        DLIB_TEST_MSG(low_count == low_counts[j],
                                     "symbol:        " << j << "\n" <<
                                     "target:        " << k << "\n" <<
                                     "low_count:     " << low_count << "\n" <<
                                     "low_counts[j]: " << low_counts[j]);
                        DLIB_TEST(high_count == high_counts[j]);
                    }

                }

            }



            print_spinner();

            for (int h = 0; h < 10; ++h)
            {


                test.clear();

                for (unsigned long k = 0; k < alphabet_size-1; ++k)
                {
                    counts[k] = 0;
                }
                counts[alphabet_size-1] = 1;
                unsigned long total = 1;
                unsigned long i = ::rand()%alphabet_size;

                unsigned long temp = 65536;
                for (unsigned long j = 0; j < temp; ++j)
                {
                    test.increment_count(i);  


                    if (total >= 65535)
                    {
                        total = 0;
                        for (unsigned long i = 0; i < alphabet_size; ++i)
                        {
                            counts[i] >>= 1;
                            total += counts[i];
                        }
                        if (counts[alphabet_size-1] == 0)
                        {
                            ++total;
                            counts[alphabet_size-1] = 1;
                        }
                    }
                    counts[i] = counts[i] + 1;
                    ++total;

                }


                DLIB_TEST(test.get_total() == total);

                unsigned long target = test.get_total()/2;
                unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;


                DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==counts[symbol]);

                if (counts[symbol] != 0)
                {
                    DLIB_TEST(total_count == total);

                    DLIB_TEST(high_count <= total);
                    DLIB_TEST(low_count < high_count);
                    DLIB_TEST(high_count <= test.get_total());
                    DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                }



                test.get_symbol(target,symbol,low_count,high_count);


                DLIB_TEST(high_count <= total);
                DLIB_TEST(low_count < high_count);
                DLIB_TEST(high_count <= test.get_total());
                DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                DLIB_TEST(test.get_count(symbol) == counts[symbol]);







            }

        } // for (int g = 0; g < 2; ++g)













        for (int g = 0; g < 2; ++g)
        {
            print_spinner();
            unsigned long amount=g+1;
            cc test(gs);
            cc test2(gs);

            DLIB_TEST(test.get_memory_usage() != 0);

            const unsigned long alphabet_size = 256;                


            DLIB_TEST(test.get_total() == 1);

            DLIB_TEST(test.get_count(alphabet_size-1)==1);
            for (unsigned long i = 0; i < alphabet_size-1; ++i)
            {
                unsigned long low_count, high_count, total_count;
                DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == 0);
                DLIB_TEST(test.get_count(i) == 0);
                DLIB_TEST(test.get_total() == 1);
            }


            bool oom = false;
            for (unsigned long i = 0; i < alphabet_size; ++i)
            {
                bool status = test.increment_count(i,static_cast<unsigned short>(amount));
                unsigned long low_count = 0, high_count = 0, total_count = 0;
                if (!status)
                    oom = true;

                if (status)
                {
                    if (i ==alphabet_size-1)
                    {
                        DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == 1+amount);

                        DLIB_TEST(high_count == low_count+1+amount);
                        DLIB_TEST(total_count == test.get_total());


                        DLIB_TEST(test.get_count(i) == 1+amount);
                    }
                    else
                    {
                        DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == amount);

                        DLIB_TEST(high_count == low_count+amount);
                        DLIB_TEST(total_count == test.get_total());


                        DLIB_TEST(test.get_count(i) == amount);
                    }
                    if (!oom)
                        DLIB_TEST(test.get_total() == (i+1)*amount + 1);
                }
            } 


            oom = false;
            for (unsigned long i = 0; i < alphabet_size; ++i)
            {        
                unsigned long temp = static_cast<unsigned long>(::rand()%40);
                for (unsigned long j = 0; j < temp; ++j)
                {
                    bool status = test.increment_count(i,static_cast<unsigned short>(amount));
                    if (!status)
                        oom = true;
                    if (status)
                    {
                        if (i == alphabet_size-1)
                        {
                            DLIB_TEST(test.get_count(i) == (j+1)*amount + 1 + amount);                    
                        }
                        else
                        {
                            DLIB_TEST(test.get_count(i) == (j+1)*amount + amount);                    
                        }
                    }
                }

                unsigned long target = test.get_total()/2;
                unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;

                if (!oom)
                {
                    if (i == alphabet_size-1)
                    {
                        DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==temp*amount+1+amount);
                        DLIB_TEST(high_count-low_count == temp*amount+1+amount);
                    }
                    else
                    {
                        DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==temp*amount + amount);
                        DLIB_TEST(high_count-low_count == temp*amount + amount);
                    }
                    DLIB_TEST(total_count == test.get_total());


                    test.get_symbol(target,symbol,low_count,high_count);
                    DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                    DLIB_TEST(low_count <= target);
                    DLIB_TEST(target < high_count);
                    DLIB_TEST(high_count <= test.get_total());
                }

            }

            test.clear();


            oom = false;
            for (unsigned long i = 0; i < alphabet_size-1; ++i)
            {
                if(!test.increment_count(i))
                    oom = true;
                unsigned long low_count = 0, high_count = 0, total_count = 0;

                if (!oom)
                {
                    DLIB_TEST(test.get_range(i,low_count,high_count,total_count) == 1);

                    DLIB_TEST(high_count == low_count+1);
                    DLIB_TEST(total_count == test.get_total());

                    DLIB_TEST(test.get_count(i) == 1);
                    DLIB_TEST(test.get_total() == i+2);
                }
            } 



            unsigned long counts[alphabet_size];


            for (int k = 0; k < 10; ++k)
            {
                unsigned long range = ::rand()%50000 + 2;

                test.clear();

                for (unsigned long i = 0; i < alphabet_size-1; ++i)
                    counts[i] = 0;
                unsigned long total = 1;
                counts[alphabet_size-1] = 1;


                oom = false;
                for (unsigned long i = 0; i < alphabet_size; ++i)
                {                
                    unsigned long temp = static_cast<unsigned long>(::rand()%range);
                    for (unsigned long j = 0; j < temp; ++j)
                    {
                        if (!test.increment_count(i))
                            oom = true;


                        if (total >= 65535)
                        {

                            total = 0;
                            for (unsigned long i = 0; i < alphabet_size; ++i)
                            {
                                counts[i] >>= 1;
                                total += counts[i];
                            }
                            if (counts[alphabet_size-1]==0)
                            {
                                counts[alphabet_size-1] = 1;
                                ++total;
                            }
                        }
                        counts[i] = counts[i] + 1;
                        ++total;


                    }


                    unsigned long temp_total = 0;
                    for (unsigned long a = 0; a < alphabet_size; ++a)
                    {
                        temp_total += test.get_count(a);
                    }

                    if (!oom)
                    {
                        DLIB_TEST_MSG(temp_total == test.get_total(),
                                     "temp_total == " << temp_total << std::endl <<
                                     "test.get_total() == " << test.get_total()
                        );

                        DLIB_TEST(test.get_count(alphabet_size-1) == counts[alphabet_size-1]);
                        DLIB_TEST_MSG(test.get_total() == total,
                                     "test.get_total() == " << test.get_total() << std::endl <<
                                     "total == " << total
                        );
                    }

                    unsigned long target = test.get_total()/2;
                    unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;

                    if (!oom)
                    {

                        DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==counts[symbol]);

                        if (counts[symbol] != 0)
                        {
                            DLIB_TEST(total_count == total);

                            DLIB_TEST(high_count <= total);
                            DLIB_TEST(low_count < high_count);
                            DLIB_TEST(high_count <= test.get_total());
                            DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                        }


                        if (target < total)
                        {
                            test.get_symbol(target,symbol,low_count,high_count);


                            DLIB_TEST(high_count <= total);
                            DLIB_TEST(low_count < high_count);
                            DLIB_TEST(high_count <= test.get_total());
                            DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                            DLIB_TEST(test.get_count(symbol) == counts[symbol]);
                        }
                    }



                }

            }

            oom = false;
            for (unsigned long h = 0; h < 10; ++h)
            {
                test.clear();
                DLIB_TEST(test.get_total() == 1);

                // fill out test with some numbers
                unsigned long temp = ::rand()%30000 + 50000;
                for (unsigned long j = 0; j < temp; ++j)
                {
                    unsigned long symbol = (unsigned long)::rand()%alphabet_size;
                    if (!test.increment_count(symbol))
                        oom = true;
                }

                // make sure all symbols have a count of at least one
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {   
                    if (test.get_count(j) == 0)
                        test.increment_count(j);
                }

                unsigned long temp_total = 0;
                for (unsigned long j = 0; j < alphabet_size; ++j)
                {
                    temp_total += test.get_count(j);
                }
                if (!oom)
                    DLIB_TEST(temp_total == test.get_total());


                unsigned long low_counts[alphabet_size];
                unsigned long high_counts[alphabet_size];

                if (!oom)
                {

                    // iterate over all the symbols
                    for (unsigned long j = 0; j < alphabet_size; ++j)
                    {
                        unsigned long total;
                        unsigned long count = test.get_range(j,low_counts[j],high_counts[j],total);
                        DLIB_TEST(count == test.get_count(j));
                        DLIB_TEST(count == high_counts[j] - low_counts[j]);

                    }




                    // make sure get_symbol() matches what get_range() told us
                    for (unsigned long j = 0; j < alphabet_size; ++j)
                    {                    
                        for (unsigned long k = low_counts[j]; k < high_counts[j]; ++k)
                        {
                            unsigned long symbol, low_count, high_count;
                            test.get_symbol(k,symbol,low_count,high_count);
                            DLIB_TEST(high_count - low_count == test.get_count(symbol));
                            DLIB_TEST_MSG(j == symbol,
                                         "j == " << j << std::endl <<
                                         "k == " << k << std::endl <<
                                         "symbol == " << symbol << std::endl <<
                                         "low_counts[j] == " << low_counts[j] << std::endl <<
                                         "high_counts[j] == " << high_counts[j] << std::endl <<
                                         "low_counts[symbol] == " << low_counts[symbol] << std::endl <<
                                         "high_counts[symbol] == " << high_counts[symbol] << std::endl << 
                                         "low_count == " << low_count << std::endl << 
                                         "high_count == " << high_count << std::endl << 
                                         "temp.count(j) == " << test.get_count(j)
                            );
                            DLIB_TEST_MSG(low_count == low_counts[j],
                                         "symbol:        " << j << "\n" <<
                                         "target:        " << k << "\n" <<
                                         "low_count:     " << low_count << "\n" <<
                                         "low_counts[j]: " << low_counts[j]);
                            DLIB_TEST(high_count == high_counts[j]);
                        }

                    }
                }

            }




            for (int h = 0; h < 10; ++h)
            {


                test.clear();

                for (unsigned long k = 0; k < alphabet_size-1; ++k)
                {
                    counts[k] = 0;
                }
                counts[alphabet_size-1] = 1;
                unsigned long total = 1;
                unsigned long i = ::rand()%alphabet_size;

                unsigned long temp = 65536;
                for (unsigned long j = 0; j < temp; ++j)
                {
                    test.increment_count(i);  


                    if (total >= 65535)
                    {
                        total = 0;
                        for (unsigned long i = 0; i < alphabet_size; ++i)
                        {
                            counts[i] >>= 1;
                            total += counts[i];
                        }
                        if (counts[alphabet_size-1] == 0)
                        {
                            ++total;
                            counts[alphabet_size-1] = 1;
                        }
                    }
                    counts[i] = counts[i] + 1;
                    ++total;

                }


                DLIB_TEST(test.get_total() == total);

                unsigned long target = test.get_total()/2;
                unsigned long symbol = i, low_count = 0, high_count = 0, total_count = 0;


                DLIB_TEST(test.get_range(symbol,low_count,high_count,total_count)==counts[symbol]);

                if (counts[symbol] != 0)
                {
                    DLIB_TEST(total_count == total);

                    DLIB_TEST(high_count <= total);
                    DLIB_TEST(low_count < high_count);
                    DLIB_TEST(high_count <= test.get_total());
                    DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                }



                test.get_symbol(target,symbol,low_count,high_count);


                DLIB_TEST(high_count <= total);
                DLIB_TEST(low_count < high_count);
                DLIB_TEST(high_count <= test.get_total());
                DLIB_TEST(test.get_count(symbol) == high_count-low_count);
                DLIB_TEST(test.get_count(symbol) == counts[symbol]);







            }

        } // for (int g = 0; g < 2; ++g)


    }

}

#endif // DLIB_TEST_CONDITIONING_CLASs_H_

