#include "SegList.hh"
#include "ParseLine.hh"
#include <iostream>

using namespace std;

//======================================  Segment list constructor
LockSegList::LockSegList(const char* lid, const char* file) 
  : mListID(lid)
{
    if (file) read(file);
}

//======================================  clear segment list
void
LockSegList::clear(void) {
    mList.clear();
}

//======================================  clear segment list
void
LockSegList::coalesce(void) {
    size_type N=size();
    size_type j=0;
    for (size_type i=0; i<N; ++i) {
        if (ref(i).getDuration() <= Interval(0.0)) continue;
        if (j && ref(j-1).overlap(ref(i))) {
	    ref(j-1) |= ref(i);
	} else {
	    if (j != i) ref(j) = ref(i);
	    j++;
	}
    }
    if (j < N) mList.erase(mList.begin()+j, mList.begin()+N);
}

//======================================  Find segment for specified time
int
LockSegList::find(const Time& t) const throw(domain_error) {
    unsigned int inx = findafter(t);
    if (inx == size() || !mList[inx].inSegment(t)) {
        throw domain_error("Time not in segment");
    }
    return inx;
}

//======================================  Find first segment after time
int
LockSegList::findafter(const Time& t) const {
    int low=0, high=size();
    while (low != high) {
        int inx = (low+high) >> 1;
	if (t < mList[inx].getEndTime()) high = inx;
	else if (inx > low)              low  = inx;
	else                             ++low;
    }
    return high;
}

//======================================  Test if time is in segment
bool
LockSegList::inSegment(const Time& t) const {
    unsigned int inx = findafter(t);
    if (inx == size()) return false;
    return mList[inx].inSegment(t);
}

//======================================  Test if time range is in segment
bool
LockSegList::inSegment(const Time& t, const Time& t2) const {
    unsigned int inx = findafter(t);
    if (inx == size()) return false;
    return mList[inx].inSegment(t, t2);
}

//======================================  Insert a segment into the list
void
LockSegList::insert(const LockSegment& l) {
    mList.insert(mList.begin()+findafter(l.getStartTime()), l);
}

//======================================  Insert a segment into the list
void
LockSegList::invert(void) {
    int N = size();
    int j = 0;
    Time last(0);
    for (int i=0; i<N; i++) {
        Time start = mList[i].getStartTime();
	if (start <= last) continue;
	Time end = mList[i].getEndTime();
	mList[j++] = LockSegment(0, last, start-last, 0);
	last = end;
    }

    //----------------------------------  Fill in the last entry
    Time tInf(SEGMENT_TINF);
    if (j==N) {
        mList.push_back(LockSegment(0, last, tInf-last, 0));
    } else {
        mList[j++] = LockSegment(0, last, tInf-last, 0);
	if (j<N) mList.erase(mList.begin()+j, mList.end());
    }
}

//======================================  write a segment ID
ostream&
LockSegList::putID(ostream& out, size_type inx) const {
    out << mListID << "-" << mList[inx].getID();
    return out;
}

//======================================  Read segments from a file.
void
LockSegList::read(const std::string& file) {
    ParseLine pl(file.c_str());
    if (!pl.isOpen()) {
        cerr << "Unable to open file: " << file << endl;
	return;
    }

    enum {
      unknown,
      segwizard,
      startend} filetype(unknown);

    while (pl.getLine() >= 0) {
        int nArg = pl.getCount();
	if (!nArg) continue;

	//------------------------------  Identify file type.
	if (filetype == unknown) {
	    if (nArg == 1 && string(pl[0]) == "seg_cit") {
	        filetype = segwizard;
		continue;
	    } else if (nArg == 2 && pl.getInt(1) > pl.getInt(0)) {
	        filetype = startend;
	    } else if (nArg >= 4 &&
		       pl.getInt(3) == pl.getInt(2)-pl.getInt(1)) {
	        filetype = segwizard;
	    } else {
	        throw runtime_error("Unrecognized segment file format");
	    }
	}

	//------------------------------  Get segment parameters.
	LockSegment::id_type id = 0;
	unsigned long start, duration;
	LockSegment::flag_type flags = 0;
	switch (filetype) {
	case startend:
	    start = pl.getInt(0);
	    duration = pl.getInt(1) - start;
	    break;
	case segwizard:
	    id = pl.getInt(0);
	    start = pl.getInt(1);
	    duration = pl.getInt(3);
	    if (nArg >= 5) flags = pl.getInt(4);
	    break;
	default:
	    throw runtime_error("Unrecognized segment file format");
	}

	//-------------------------------  Insert the segments
	insert(LockSegment(id, Time(start), Interval(duration), flags));
    }
}

//======================================  Calculate union of segment lists.
LockSegList&
LockSegList::operator|=(const LockSegList& l) {
    size_type N2=l.size();
    for (size_type i=0, j=0; j<N2;) {
        if (i >= size() || l[j].getEndTime() < ref(i).getStartTime()) {
	    insert(l[j++]);
	} else if (ref(i).getEndTime() < l[j].getStartTime()) {
	    i++;
	} else {
	    Time t0=l[j].getStartTime();
	    if (i && t0 < ref(i-1).getEndTime()) t0=ref(i-1).getEndTime();
	    if (ref(i).getStartTime() < t0) t0=ref(i).getStartTime();
	    Time tEnd = l[j].getEndTime();
	    if (ref(i).getEndTime() > tEnd) tEnd = ref(i).getEndTime();
	    if (i+1 < size() && tEnd > ref(i+1).getStartTime()) {
	      tEnd=ref(i+1).getStartTime();
	    }
	    ref(i).setRange(t0, tEnd-t0);
	    j++;
	}
    }
    return *this;
}

//======================================  Calculate intersection of two lists
LockSegList&
LockSegList::operator&=(const LockSegList& l) {
    size_type N2=l.size();
    for (size_type i=0, j=0; j<N2 && i<size(); ) {
	if (ref(i).overlap(l[j])) {
	    Time tEndi = ref(i).getEndTime();
	    if (j+1 < N2 || l[j+1].getStartTime() < tEndi) {
	        LockSegment seg(ref(i));
		seg.setRange(l[j].getEndTime(), tEndi);
		ref(i) &= l[j];
		insert(seg);
	    } else {
		ref(i) &= l[j];
	    }
	    if (l[j].getEndTime() < tEndi) j++;
	    i++;
	} else if (l[j] < ref(i)) {
	    j++;
	} else {
	    mList.erase(mList.begin()+i);
	}
    }
    return *this;
}

//======================================  Test if [t1:t2] overlaps a segment
bool 
LockSegList::overlap(const Time& t, const Time& t2) const {
    size_type N = size();
    size_type inx = findafter(t);
    if (inx == N) return false;
    if (mList[inx].overlap(t, t2)) return true;
    inx++;
    if (inx < N && mList[inx].overlap(t, t2)) return true;
    return false;
}

//======================================  Set the debug level.
void
LockSegList::setDebug(int lvl) {
    mDebug = lvl;
}