/**
*  Copyright (c) 2011 Ubimet
*
*  Distributed under the Boost Software License, Version 1.0. (See accompanying
*  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
**/

#include <boost/assign/std/vector.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/karma_binary.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_binary.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/support_multi_pass.hpp>
#include <algorithm>
#include <cassert>
#include <climits>
#include <iostream>
#include <iterator>
#include <fstream>
#include <vector>
using namespace boost::assign;

struct float_data
{
    float f;
    double d;
    std::vector<float> vf;
    std::vector<double> vd;

    bool operator==(const float_data &rhs) const
    {
        return f == rhs.f && d == rhs.d &&
            std::equal(vf.begin(), vf.end(), rhs.vf.begin()) &&
            std::equal(vd.begin(), vd.end(), rhs.vd.begin());
    }
};

BOOST_FUSION_ADAPT_STRUCT
(
    float_data,
    (float, f)
    (double, d)
    (std::vector<float>, vf)
    (std::vector<double>, vd)
)

template<typename Iterator>
struct float_parser: boost::spirit::qi::grammar<Iterator, float_data()>
{
    float_parser(): float_parser::base_type(start)
    {
        using boost::spirit::byte_;
        using boost::spirit::bin_float;
        using boost::spirit::big_bin_float;
        using boost::spirit::little_bin_float;
        using boost::spirit::bin_double;
        using boost::spirit::big_bin_double;
        using boost::spirit::little_bin_double;
        using boost::spirit::repeat;

        start =
            (
                bin_float(1.0f) >> big_bin_float(1.0f) >>
                    little_bin_float(1.0f) >> bin_double(1.0) >>
                    big_bin_double(1.0) >> little_bin_double(1.0)
            ) >>
            (
                bin_float >> bin_double >> repeat(7)[bin_float] >>
                    repeat(5)[bin_double]
            )
        ;
    }

    boost::spirit::qi::rule<Iterator, float_data()> start;
};

template<typename OutputIterator>
struct float_generator: boost::spirit::karma::grammar<OutputIterator,
    float_data()>
{
    float_generator(): float_generator::base_type(start)
    {
        using boost::spirit::byte_;
        using boost::spirit::bin_float;
        using boost::spirit::big_bin_float;
        using boost::spirit::little_bin_float;
        using boost::spirit::bin_double;
        using boost::spirit::big_bin_double;
        using boost::spirit::little_bin_double;

        start =
            (
                bin_float(1.0f) << big_bin_float(1.0f) <<
                    little_bin_float(1.0f) << bin_double(1.0) <<
                    big_bin_double(1.0) << little_bin_double(1.0)
            ) <<
            (
                bin_float << bin_double << *bin_float <<
                    *bin_double
            )
        ;
    }

    boost::spirit::karma::rule<OutputIterator, float_data()> start;
};

int main()
{
    std::ofstream out("float.bin", std::ios::binary | std::ios::trunc);
    if(!out)
    {
        std::cerr << "Failed to open output file\n";
        return 1;
    }

    typedef std::ostream_iterator<char> iterator;
    typedef float_generator<iterator> float_generator;
    float_generator fg;

    float_data fd1;
    fd1.f = 3.1416f; // Pi.
    fd1.d = 1.41421356; // Sqrt(2)
    fd1.vf += 1.0f, 1.0f, 2.0f, 3.0f, 5.0f, 8.0f, 13.0f; // Fibonacci.
    fd1.vd += 2.0, 3.0, 5.0, 7.0, 11.0; // Primes.

    bool result = boost::spirit::karma::generate(iterator(out), fg, fd1);

    out.close();

    if(!result)
    {
        std::cerr << "Failed to generate\n";
        return 1;
    }

    std::ifstream in("float.bin", std::ios::binary);
    if(!in)
    {
        std::cerr << "Failed to open input file\n";
        return 1;
    }

    namespace spirit = boost::spirit;

    typedef std::istreambuf_iterator<char> base_iterator_type;
    spirit::multi_pass<base_iterator_type> first =
        spirit::make_default_multi_pass(base_iterator_type(in));
    spirit::multi_pass<base_iterator_type> last =
        spirit::make_default_multi_pass(base_iterator_type());

    typedef float_parser<spirit::multi_pass<
        base_iterator_type> > float_parser;
    float_parser fp;

    float_data fd2;
    bool result2 = parse(first, last, fp, fd2);

    in.close();

    if(!result2 || first != last)
    {
        std::cerr << "Failed to parse\n";
        return 1;
    }

    assert(fd2 == fd1);

    return 0;
}