//
//  StreamBuffer.cpp
//  NetworkStreamEmulator
//
//  Created by Yifei Zhou on 7/11/14.
//  Copyright (c) 2014 Yifei Zhou. All rights reserved.
//

#include "StreamBuffer.h"
#include <map>
#include <string>
#include <fstream>

#define DEBUG_OUTPUT

StreamBuffer::StreamBuffer(ofstream &t_handle)
:handle(t_handle)
{
    minSeq = LONG_MAX;
    maxSeq = LONG_MIN;
    
    bufferSize = 0;
    storedSize = 0;
    buffer.clear();

}

StreamBuffer::~StreamBuffer()
{
    bufferSize = 0;
    storedSize = 0;
    // Write Remaining data
    for (map<long, Frame>::iterator iter = buffer.begin(); iter != buffer.end(); iter++) {
        Frame f = iter->second;
        handle.seekp(f.offset);
        handle.write(f.data, f.size);
#ifdef DEBUG_OUTPUT
        cout << "Stored Leftover: Offset: " << f.offset << ", Size: " << f.size << endl;
#endif
    }
    buffer.clear();
    //handle.close();
}

long StreamBuffer::ReceiveFrame(const Frame *f)
{
    if (bufferSize <= MAX_BUFFER_SIZE) {
        buffer[f->seq] = *f;
        bufferSize += f->size;
        if (f->seq <= minSeq) {
            minSeq = f->seq;
        }
        if (f->seq >= maxSeq) {
            maxSeq = f->seq;
        }
    } else {
#ifdef DEBUG_OUTPUT
        cout << "Dropped: Offset: " << f->offset << ", Size: " << f->size << endl;
#endif
    }
    return bufferSize;
}


tuple<long, long, long> StreamBuffer::SortedData(long &bufferSize)
{
    long sortedSize;
    if (bufferSize >= MAX_WINDOW_SIZE) {
        // Quick Search
        for (long seq = maxSeq-MAX_WINDOW_SIZE/MTU; seq <= maxSeq; seq++) {
            // Fixed Windows Size
            sortedSize = 0;
            long t_seq = seq;
            while (sortedSize <= MAX_WINDOW_SIZE) {
                map<long, Frame>::iterator iter = buffer.find(t_seq);
                if (iter != buffer.end()) {
                    sortedSize += iter->second.size;
                    t_seq++;
                } else {
                    break;
                }
            }
            if (sortedSize >= MAX_WINDOW_SIZE || t_seq > maxSeq) {
                return make_tuple(seq, t_seq, sortedSize);
            }
        }
    }
    if (bufferSize >= MAX_BUFFER_SIZE) {
        // Deep Search
        for (long seq = minSeq; seq <= maxSeq; seq++) {
            // Fixed Windows Size
            sortedSize = 0;
            long t_seq = seq;
            while (sortedSize <= MAX_WINDOW_SIZE) {
                map<long, Frame>::iterator iter = buffer.find(t_seq);
                if (iter != buffer.end()) {
                    sortedSize += iter->second.size;
                    t_seq++;
                } else {
                    break;
                }
            }
            if (sortedSize >= MAX_WINDOW_SIZE || t_seq > maxSeq) {
                return make_tuple(seq, t_seq, sortedSize);
            }
        }
    }
    return make_tuple(-1, -1, 0);
}

long StreamBuffer::StoreSortedData(long &bufferSize)
{
    tuple<long, long, long> t = SortedData(bufferSize);
    long sortedSize = get<2>(t);
    const long startSeq = get<0>(t);
    const long endSeq = get<1>(t);
    
    if (sortedSize >= MAX_WINDOW_SIZE) {
        for (long i = startSeq; i < endSeq; i++) {
            Frame f = buffer.find(i)->second;
            handle.seekp(f.offset);
            handle.write(f.data, f.size);
#ifdef DEBUG_OUTPUT
            cout << "Stored: SEQ: " << i << ", Size: " << f.size << endl;
#endif
            buffer.erase(i);
        }
    }
    
    if (startSeq == minSeq) {
        minSeq = endSeq+1;
    }
    if (endSeq == maxSeq) {
        maxSeq = startSeq-1;
    }
    bufferSize -= sortedSize;
    storedSize += sortedSize;
    return sortedSize;
}

long StreamBuffer::StoredSize()
{
    return storedSize;
}