#include <forward_list>
#include <iostream>

using namespace std;

int main()
{
    forward_list<int> fl = {1, 2, 3, 4, 5};

    for (const auto &elem : fl)
    {
        cout << elem;
    }

    return 0;
}

*c.before_begin();      // undefined behaviour
*c.end();               // undefined behaviour

//----------------------- find and modify  ----------------------
RUN_GTEST(ForwardListTest, FindAndModify, @);

forward_list<int> fl = { 1, 2, 3 };
printContainer(fl, "fl: ");                 // fl: 1 2 3

// 找偶数用
auto isEven = [](int i) -> bool
{
    return (i % 2 == 0);
};

auto deletePos = find_if(fl.begin(), fl.end(), isEven);

// 接下来怎么写，不行了，我已经走过头了，deletePos虽然是我要删除元素的位置，
// 但是我要调用erase_after， 那么就要把deletePos前面的位置传给erase_after.

// 因此为了要记住deletePos之前的位置，我得这么写：

// pos是要删除的元素，posBefore是pos的前一个元素
forward_list<int>::iterator posBefore, pos;

posBefore = fl.before_begin();

for (pos = fl.begin(); pos != fl.end(); posBefore = pos, ++pos)
{
    if (*pos % 2 == 0)
    {
        // 找到了
        break;
    }
}

if (pos != fl.end())
{
    // 把pos的前一个位置传给erase
    fl.erase_after(posBefore);
    printContainer(fl, "fl: ");                 // fl: 1 3
}


// 这个过程是不是有些麻烦，要定义两个迭代器位置，
// 其实可以使用迭代器辅助函数: next(pos, n)来简化, 
// next的作用很简单，返回pos的下n个位置，n默认为1.

// 下面用next来完成查找过程：

// 把list恢复成 1 2 3
fl.insert_after(posBefore, 2);
printContainer(fl, "fl: ");                     // fl: 1 2 3

posBefore = fl.before_begin();
for (; next(posBefore) != fl.end(); ++posBefore)
{
    int i = *next(posBefore);
    if (isEven(i))
    {
        // 找到了
        break;
    }
}


if (next(posBefore) != fl.end()) 
{
    fl.erase_after(posBefore);
    printContainer(fl, "fl: ");              // fl: 1 3
}

//----------------------- splice ----------------------
RUN_GTEST(ForwardListTest, SpliceTest, @);

forward_list<int> fl1 = { 1, 2, 3, 4, 5 };
forward_list<int> fl2 = { 97, 98, 99 };

printContainer(fl1, "fl1: ");       // 1 2 3 4 5
printContainer(fl2, "fl2: ");       // 97 98 99

auto pos1 = fl1.before_begin();                 
for ( ; next(pos1) != fl1.end(); ++pos1 )
{
    if ( *next(pos1) == 3 )         // find 3, pos1 is position before 3.
    {
        break;
    }
}

auto pos2 = fl2.before_begin();
for ( ; next(pos2) != fl2.end(); ++pos2 )
{
    if ( *next(pos2) == 99 )        // find 99, pos2 is position before 99.
    {
        break;
    }
}


// 书中原始代码为：
// fl1.splice_after(pos2, fl2,         // destination
//                  pos1);             // source

// 可能是这个函数之前的作用和现在标准发布的用法不一致，
// 作者的代码用反了source和destination. 我运行这段代码程序报错了。
// 结合书中对splice_after函数的解释，正确的用法 应该是下面这样：

// 把fl1中pos1后面的一个元素，移动到fl2中pos2后面。
fl2.splice_after(pos2,              // 目的地
                 fl1, pos1);        // 源

// 要移动到fl2中，那么fl2是目标，所以要用fl2来调用splice_after.
// pos2是fl2中的位置，它是目的地，应该作为第一个参数；
// fl1是源，作为第二个参数；
// pos1则是源fl1中的具体位置，作为第三个参数。


printContainer(fl1, "fl1: ");       // 1 2 4 5
printContainer(fl2, "fl2: ");       // 97 98 3 99
END_TEST;

// 返回(begin, end)之间，值等于val的元素的前一个位置pos. 开区间，不包括begin和end
template <typename ForwardIter, typename T>
ForwardIter find_before(ForwardIter beg, ForwardIter end, const T &val)
{
    auto posBefore = beg;
    while (beg != end)
    {
        if (*beg == val) 
        {
            return posBefore;
        }
        posBefore = beg;
        ++beg;
    }
    return end;
}

// 返回(begin, end)之间，满足op(elem) == true的元素的前一个位置pos. 注意是开区间，不包括begin和end
template <typename ForwardIter, typename Pred>
ForwardIter find_before_if(ForwardIter beg, ForwardIter end, Pred op)
{
    auto posBefore = beg;
    ++beg;
    while (beg != end)
    {
        if (op(*beg))
        {
            return posBefore;
        }
        posBefore = beg;
        ++beg;
    }
    return end;
}

//----------------------- test find_before  ----------------------
RUN_GTEST(ForwardListTest, FindBefore, @);

forward_list<int> fl = { 1, 2, 3 };
printContainer(fl, "original fl: ");                 // 1 2 3

//------------------ find_before -----------------------
auto posBefore2 = find_before(fl.begin(), fl.end(), 2);
if (posBefore2 != fl.end()) 
{
    fl.erase_after(posBefore2);
    printContainer(fl, "delete 2: ");                 // 1 3
}


//------------------ find_before_if -----------------------
auto isEven = [](int i) -> bool
{
    return (i % 2 == 0);
};

// recover fl contents to 1 2 3.
fl.clear();
fl.insert_after(fl.before_begin(), {1, 2, 3});
printContainer(fl, "original fl: ");                 // 1 2 3


posBefore2 = find_before_if(fl.begin(), fl.end(), isEven);
if (posBefore2 != fl.end()) 
{
    fl.erase_after(posBefore2);
    printContainer(fl, "delete first even: ");      // 1 3
}

END_TEST;