/*--------------------------------------------------------------------------
  Project:  HorizonSDK
  File:     rdt_ResendQueue.cpp

  Copyright 2009 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Date:: 2010-09-16#$
  $Rev: 26004 $
  $Author: hiratsu_daisuke $
 *-------------------------------------------------------------------------*/

#include "stdafx.h"

#include "rdt_ResendQueue.h"

#include <string.h>

#include "Test.h"

#include "rdt_Utility.h"


namespace
{

}  // end of anonymous namespace

namespace nn { namespace rdt { namespace CTR {


ResendQueue::ResendQueue(void)
     :m_bResendMode(false)
{
    Clear();
}


ResendQueue::~ResendQueue(void)
{
}


bool ResendQueue::Push(const Segment &seg)
{
    if(m_queue.IsFull())
    {
        return false;
    }

    // TORIAEZU
    SegmentWithTime swt;
    swt.segment   = seg;
    swt.timeStamp = nn::rdt::CTR::GetCurrentTimeAsMillisecond();

    // データセグメントと違い、SYNセグメントはハイペースで送る必要はない。
    if(seg.IsSyn())
    {
        swt.timeOut = SYN_SEGMENT_TIMEOUT;
    }
    else
    {
        swt.timeOut = m_defaultTimeout;
    }


    if(!m_queue.IsEmpty())
    {
        // 新しい実装では、タイムスタンプの半順序関係は
        // もはや保証できなくなっています（再送モードでは、半順序関係が崩れる）
        // しかし、その状態でこの関数が呼び出される（＝再送処理が終わっていないのに、
        // 新しいデータを送信しようとしている）のは問題であるので、このコードは
        // もう少し残しておきます。
        // キューに記録されている要素群のタイムスタンプが半順序関係を
        // 保っているかどうかをチェックします。
        ASSERT(swt.timeStamp >= m_queue.Back().timeStamp);
    }

    m_queue.PushBack(swt);

    return true;
}


bool ResendQueue::Front(Segment *pSeg) const
{
    ASSERT(pSeg!=NULL);

    if(m_queue.IsEmpty())
    {
        return false;
    }
    else
    {
        *pSeg = m_queue.Front().segment;
        return true;
    }
}


// TORIAEZU
// Remove()については見直しが必要。もはやキューがタイムスタンプの順に並ぶことは
// 仮定できなくなってしまっているから。
// この実装だと、Remove()対象がキューの先頭以外にある場合に、対象が除去されない。
void ResendQueue::Remove(u32 ack)
{
    while(!m_queue.IsEmpty())
    {
        const Segment &seg = m_queue.Front().segment;
        u32 lastSeq = seg.GetLastSeqNumber();

        if(0 < static_cast<s32>(ack) - static_cast<s32>(lastSeq))
        {
            m_queue.PopFront();
            VERBOSE("再送キューの先頭を除去しました。\n");
            if(m_queue.IsEmpty())
            {
                // 再送キューをカラッポにしてしまったのならば、再送モードは終了。
                m_bResendMode = false;
            }
        }
        else
        {
            // 先頭でさえACKによる到達確認が取れないのであれば、
            // 後続のセグメントは言うに及ばす。ループを抜ける。
            break;
        }
    }
}


bool ResendQueue::IsResendRequired(void) const
{
    if(m_queue.IsEmpty())
    {
        return false;
    }
    else
    {
        return m_queue.Front().IsTimeOut();
    }
}


u32 ResendQueue::GetTotalDataSize(void) const
{
    u32 ret = 0;
    for(size_t i= 0; i<m_queue.Size(); ++i)
    {
        ret += m_queue.At(i).segment.GetDataLength();
    }

    return ret;
}


void ResendQueue::Clear(void)
{
    m_queue.Clear();
    m_defaultTimeout = DEFAULT_TIMEOUT;
}


// 先頭要素を後ろに。このとき、要素のタイムスタンプは変更される。
void ResendQueue::TryAgain(void)
{
    ASSERT(IsResendMode());

    // 先頭要素を後ろへ。再送モードフラグもセット。
    struct SegmentWithTime s = m_queue.Front();
    m_queue.PopFront();
    s.timeStamp = nn::rdt::CTR::GetCurrentTimeAsMillisecond();
    if(!m_bResendMode)
    {
        // 初めてのTryAgain()だったら、要素にマークを付ける。
        // 再送モードフラグも立てる。
        s.resendMark = true;
        m_bResendMode = true;
    }
    m_queue.PushBack(s);

    if(m_queue.Front().resendMark)
    {
        // TryAgain()を何度も呼び出すことで、一巡した！
        // 再送モードフラグは落とす
        m_queue.Front().resendMark = false;
        m_bResendMode = false;
    }
}


bool ResendQueue::IsResendMode(void) const
{
    return m_bResendMode || IsResendRequired();
}


void ResendQueue::PrintDebugInfo(void) const
{
    LOG("Number of ResendQueue elements: %d, total data size is %d bytes.\n", m_queue.Size(), GetTotalDataSize());
}


void ResendQueue::Test(void)
{
    char data[100 + 50 + 30];
    memset(data, 0, 100 + 50 + 30);

    ResendQueue r;
    r.SetDefaultTimeout(500);  // 500ミリ秒の再送タイムアウト

    const u32 SEQ = 5000;

    Segment a;  // データは100バイトとする
    a.SetData(data, 100);
    a.SetSeqNumber(SEQ);

    Segment b;  // データは50バイトとする
    b.SetData(data+100, 50);
    b.SetSeqNumber(SEQ + 100);

    Segment c;  // データは30バイトとする
    c.SetData(data+100+50, 30);
    c.SetSeqNumber(SEQ + 100 + 50);

    CU_ASSERT(r.Push(a));
    CU_ASSERT(r.m_queue.Size()==1);
    r.Remove(SEQ);
    CU_ASSERT(r.m_queue.Size()==1);  // 変化はないはず

    r.Remove(SEQ+99);
    CU_ASSERT(r.m_queue.Size()==1);  // まだ変化はないはず

    r.Remove(SEQ+100);
    CU_ASSERT(r.m_queue.Size()==0);  // 取り除かれるはず

    CU_ASSERT(r.Push(b));
    CU_ASSERT(r.Push(c));
    CU_ASSERT(r.m_queue.Size()==2);
    
    r.Remove(SEQ+101);
    CU_ASSERT(r.m_queue.Size()==2);

    r.Remove(SEQ+149);
    CU_ASSERT(r.m_queue.Size()==2);

    r.Remove(SEQ+180);
    CU_ASSERT(r.m_queue.Size()==0);

    // 以降、タイムアウトのチェック

    r.SetDefaultTimeout(500);
    Segment d;
    CU_ASSERT(r.Push(a));
    CU_ASSERT(r.m_queue.Size()==1);
    CU_ASSERT(!r.IsResendRequired());
    SleepCurrentThread(200);
    CU_ASSERT(!r.IsResendRequired());
    SleepCurrentThread(500);
    CU_ASSERT(r.IsResendRequired());
    CU_ASSERT(r.IsResendRequired());
    CU_ASSERT(r.m_queue.Size()==1); 

    CU_ASSERT(r.Push(a));
    SleepCurrentThread(300);
    CU_ASSERT(r.Push(b));
    SleepCurrentThread(300);
    CU_ASSERT(r.m_queue.Size()==3);
    CU_ASSERT(r.IsResendRequired());
    r.Remove(SEQ+100);
    CU_ASSERT(!r.IsResendRequired());
    CU_ASSERT(r.m_queue.Size()==1);

    // 以降、IsResendMode()、TryAgain()のチェック。
    Segment e, f, g;
    r.Clear();
    r.SetDefaultTimeout(500);
    CU_ASSERT(r.m_queue.Size()==0);
    CU_ASSERT(!r.IsResendMode());
    CU_ASSERT(r.Push(e));
    SleepCurrentThread(400);
    CU_ASSERT(r.Push(f));
    CU_ASSERT(r.Push(g));
    SleepCurrentThread(200);  // この時点で、eはタイムアウトになっている。
    CU_ASSERT(r.IsResendMode());  // 1個、タイムアウトの要素があるので、再送モードになっていなければならない。
    r.TryAgain();
    CU_ASSERT(r.IsResendMode());
    r.TryAgain();
    CU_ASSERT(r.IsResendMode());
    r.TryAgain();
    CU_ASSERT(!r.IsResendMode()); // 全要素が一巡したので、再送モードからは外れるはず。
    CU_ASSERT(r.m_queue.Size()==3);

    // SYNセグメントのチェック
    r.Clear();
    Segment s;
    s.SetSyn();
    r.SetDefaultTimeout(10);
    r.Push(s);
    SleepCurrentThread(150);
    CU_ASSERT(!r.IsResendRequired());  // SYNセグメントのタイムアウト値は長めにしてあるので、まだ再送対象にはならない。
    SleepCurrentThread(150);
    CU_ASSERT(r.IsResendRequired());
}

}}} // namespace nn::rdt::CTR