#include <iostream>
#include <stdlib.h>
#include "FlowList.h"
#include <fstream>
using namespace std;

FlowList::FlowList()
	:headM(0)
{
}

FlowList::FlowList(const FlowList& source)
{
	copy(source);
}

FlowList::~FlowList()
{
	destroy();
}

FlowList& FlowList::operator = (const FlowList& rhs)
{
	if (this != &rhs)
	{
		destroy();
		copy(rhs);
	}
	return *this;
}

double FlowList::average() const
{
	double sum = 0;
	Node *p;
	if (headM == NULL)
		return 0;
	p = headM;
	while (p != NULL)
	{
		sum = sum + p -> item.flow;
		p = p -> next;
	}
	return sum/count();
}

double FlowList::median() const
{
	int i=0;
	double sum =0;
	Node *q;
	q = headM;
	if (count()%2 == 0)
	{
		for (i = 0; i < (count()/2 -2); i++)
		{
			q = q -> next;
		}
		sum = q -> item.flow;
		q = q -> next;
		sum = sum + q -> item.flow;
		return sum/2;
	}
	if (count()%2 == 1)
	{
		for (i = 0; i < (count()/2 - 1); i++)
		{
			q = q -> next;
		}
		return q -> item.flow;
	}
}

void FlowList::insert(const ListItem& itemA)
{
	Node *new_node = new Node;
	new_node -> item.year = itemA.year;
	new_node -> item.flow = itemA.flow;
	if (headM == NULL || itemA.flow <= headM -> item.flow)
	{
		new_node -> next = headM;
		headM = new_node;
	}
	else
	{
		Node *before = headM;
		Node *after = headM -> next;
		while (after != NULL && itemA.flow > after -> item.flow)
		{
			before = after;
			after = after -> next;
		}
		if (itemA.flow == after -> item.flow)
		{
			cout<<"Error: duplicate year"<<endl;
		}
		else
		{
			new_node -> next = after;
			before -> next = new_node;
			cout<<"New record inserted successfully."<<endl;
		}
	}
}

void FlowList::remove(const ListItem& itemA)
{
	if (headM == NULL || headM -> item.year > itemA.year)
		return;
	Node *doomed_node = NULL;
	if (itemA.year == headM -> item.year)
	{
		doomed_node = headM;
		headM = headM -> next;
	}
	else
	{
		Node *before = headM;
		Node *maybe_doomed = headM -> next;
		while(maybe_doomed != 0 && itemA.year != maybe_doomed->item.year)
		{
      		before = maybe_doomed;
      		maybe_doomed = maybe_doomed->next;
    		}
		if (maybe_doomed != 0 && maybe_doomed->item.year == item.year) 
		{
		  doomed_node = maybe_doomed;
		  before -> next = maybe_doomed -> next;
		  cout<<"Record was successfully removed."<<endl;
		}
	}
	delete doomed_node;
}

int FlowList::count() const
{
	int i=1;
	Node *m;
	m = headM -> next;
	while(m != NULL)
	{
		i++;
		m = m -> next;
	}
}

void FlowList::destroy()
{
	Node *R;
	R = headM;
	headM = headM -> next;
	delete R;
}

void FlowList::copy(const FlowList& source)
{
	Node *s;
	Node *t;
	if (source.headM == NULL)
	{
		headM = NULL;
	}
	else
	{
		destroy();
		headM = new Node;
		s = source.headM -> next;
		t = headM;
		headM -> item = source.headM -> item;
		headM -> next = NULL;
		while(s != NULL)
		{
			t -> next = new Node;
			t = t -> next;
			t -> item = s -> item;
			t -> next = NULL;
			s = s -> next;
		}
	}
}

void FlowList::display()
{
	Node *m;
	m = headM;
	while (m != NULL)
	{
		cout<<"Year		Flow (in billions of cubic meters)"<<endl;
		cout<<"-------------------------------------------"<<endl;
		cout<<m -> item.year<<"		"<<m -> item.flow<<endl;
		m = m -> next;
	}
}

void FlowList::export()
{
	ofstream outObj;
	Node *n;
	n = headM;
	outObj.open("flow.dat");
	if (!outObj)
	{
		cout<<"There was an error opening the file."<<endl;
		return;
	}
	while(n != NULL)
	{
		outObj<<n -> item.year<<setw(5)<<n -> item.flow<<endl;
		n = n -> next;
	}
	cout<<"Data are saved into the file."<<endl;
}