#include <iostream>
//#include "lista_polje.h"
#include "lista_pokazivaci.h"
 
using namespace std;
 
int sifra;
 
int novi_unos(t_lista *L){
	cout << "Dodavanje nove zivotinje" << endl << endl;
	t_zivotinja x;
	cout << "Sifra: " << sifra << endl; x.sifra = sifra;
	cin.ignore(); 
	cout << "Vrsta: "; cin.getline(x.vrsta,20);
	cout << "Naziv: "; cin.getline(x.naziv,20);
	cout << "Cijena: "; cin >> x.cijena;
	cout << "Datum dostave: "; cin >> x.datum;
	int provjera = InsertL(x, EndL(L), L);
	if(provjera == OK){
		cout << endl << "Zapis je uspjesno dodan" << endl;
		sifra++;
		return 1;
	}
	return 0;
}
 
int ispis(t_lista *L, int granica=20000101){
	if(EndL(L) == FirstL(L)) return 0;
	t_zivotinja x;
	int brojac = 0;
	element zadnji = PreviousL(EndL(L),L);
	while(true){
		x = RetrieveL(zadnji, L);
		if(x.datum<granica){
			if(zadnji == FirstL(L)) break;
			zadnji = PreviousL(zadnji, L);
			continue;
		}
		cout << "Sifra: " << x.sifra << endl;
		cout << "Vrsta: " << x.vrsta << endl;
		cout << "Naziv: " << x.naziv << endl;
		cout << "Cijena: " << x.cijena << endl;
		cout << "Datum dostave: " << x.datum << endl;
		cout << endl;
		brojac++;
		if(zadnji == FirstL(L)) break;
		zadnji = PreviousL(zadnji, L);
	}
	cout << "+-+-+-+" << endl;
	cout << "Ukupno zivotinja: " << brojac << endl;
	cout << "+-+-+-+" << endl;
	return 1;
}
 
int brisi_po_nazivu(t_lista *L){
	cin.ignore();
	t_zivotinja x;
	x.sifra = 0;
	strcpy(x.vrsta,"");
	cout << "Unesite naziv: "; cin.getline(x.naziv,20);
	element p = LocateL(x,L);
	if( DeleteL(p,L) ) return 1;
	return 0;
}
 
int brisi_po_vrsti(t_lista *L){
	cin.ignore();
	int brisano = false;
	t_zivotinja x;
	x.sifra = 0;
	strcpy(x.naziv,"");
	cout << "Unesite vrstu: "; cin.getline(x.vrsta,20);
	element p = LocateL(x,L);
	do{
		DeleteL(p,L);
		p = LocateL(x,L);
	}while(p!=EndL(L));	
	if(brisano) return 1;
	return 0;
}
 
void Spoji(t_zivotinja *A,int i,int k,int j) {
     int I=i, J=k+1, K=0;
     t_zivotinja *B = new t_zivotinja [j-i+1];
     while (I<=k && J<=j)
           if (A[I].cijena>A[J].cijena || 
(A[I].cijena==A[J].cijena && strcmp(A[I].naziv,A[J].naziv)>0) )
              B[K++]=A[I++];
           else 
                B[K++]=A[J++];
     if (I>k)
        while (J<=j)
              B[K++] = A[J++];
     else
         while (I<=k)
               B[K++] = A[I++];
     for (int I=0;I<=j-i;I++) 
         A[i+I]=B[I];
     delete []B;
}
void MSort(t_zivotinja *A,int i, int j) {
     if (i<j) {
        int k=(i+j)/2;
        MSort(A,i,k);
        MSort(A,k+1,j);
        Spoji(A,i,k,j);
     }
}
void MSort(t_zivotinja *A,int N) {
     MSort(A,0,N-1);
}
 
void sortiraj(t_lista *L){
	element zadnji = PreviousL(EndL(L),L);
	int brojac = 0;
	while(true){
		brojac++;
		if(zadnji == FirstL(L)) break;
		zadnji = PreviousL(zadnji, L);
	}
	t_zivotinja temp[brojac];
	zadnji = PreviousL(EndL(L),L);
	int i=0;
	while(true){
		temp[i++] = RetrieveL(zadnji, L);
		if(zadnji == FirstL(L)) break;
		zadnji = PreviousL(zadnji, L);
	}
	MSort(temp,brojac);
	DeleteAllL(L);
	for(int i=0; i<brojac; i++)
		InsertL(temp[i], EndL(L), L);
}
 
int main(){
	int izbor;
 
	t_lista *L = InitL(L);
	sifra = 1000;
 
	do{
		cout << "1. Dodaj novu zivotinju" << endl;
		cout << "2. Ispis zivotinja" << endl;
		cout << "3. Ispis nakon 23.09.2012." << endl;
		cout << "4. Brisi po nazivu" << endl;
		cout << "5. Brisi cijelu vrsti" << endl;
		cout << "6. Sortiranje" << endl;
		cout << "0. Kraj" << endl;
		cout << "Vas izbor: ";
		cin >> izbor;
		cout << endl << endl;
		switch(izbor){
			case 1: novi_unos(L); break;
			case 2: ispis(L); break;
			case 3: ispis(L,20120923); break;
			case 4: brisi_po_nazivu(L); break;
			case 5: brisi_po_vrsti(L); break;
			case 6: sortiraj(L); break;
			case 0: cout << "Kraj rada" << endl; break;
			default: cout << "Krivi unos" << endl;
		}
		cout << endl << endl;
	}while(izbor);
 
	return 0;
}
 
 
 
 
 
//lista_pokazivaci.h
#include <iostream>
#include <string.h>
#define OK 1
#define ERROR -1
using namespace std;
 
struct t_zivotinja{
	int sifra;
	char vrsta[20];
	char naziv[20];
	float cijena;
	unsigned int datum;
};
 
struct t_lista{
	t_zivotinja zivotinja;
	t_lista *sljedeci;
};
 
typedef t_lista *element;
 
element FirstL(t_lista *L){
	return L->sljedeci;
}
 
element EndL(t_lista *L){
	t_lista *zadnji = L;
	while(zadnji->sljedeci)
		zadnji = zadnji->sljedeci;
	return zadnji;
}
 
element NextL(element p, t_lista *L){
	if(p->sljedeci==NULL) return EndL(L);
	return p->sljedeci;
}
 
element PreviousL(element p, t_lista *L){
	if(p == FirstL(L)) return NULL;
	t_lista *zadnji = L->sljedeci;
	while(p!=zadnji->sljedeci && zadnji->sljedeci!=NULL)
		zadnji = zadnji->sljedeci;
	return zadnji;
}
 
element LocateL(t_zivotinja x, t_lista *L){
	t_lista *zadnji = L->sljedeci;
	while(zadnji){
		if(x.sifra==zadnji->zivotinja.sifra || 
		!strcmp(zadnji->zivotinja.naziv,x.naziv) || 
		!strcmp(zadnji->zivotinja.vrsta,x.vrsta))
			return zadnji;
		zadnji = zadnji->sljedeci;
	}
	return EndL(L);
}
 
int InsertL(t_zivotinja x, element p, t_lista *L){
	t_lista *zadnji = p;
	t_lista *novi = new t_lista;
 
	if(p == EndL(L)){
		novi->sljedeci = NULL;
		zadnji->sljedeci = novi;
		zadnji->zivotinja = x;
	} else if(p == FirstL(L)){
		novi->sljedeci = zadnji;
		L->sljedeci = novi;
		novi->zivotinja = x;
	} else{
		t_lista *prethodni = PreviousL(p,L);		
		novi->sljedeci = prethodni->sljedeci;
		prethodni->sljedeci = novi;
		novi->zivotinja = x;
	}
	if(zadnji->zivotinja.sifra==x.sifra) return OK;
	return ERROR;
}
 
int DeleteL(element p, t_lista *L){
	t_lista *prethodni, *zadnji = p;
	if(p == FirstL(L)){
		L->sljedeci = zadnji->sljedeci;
		delete zadnji;
		return 1;
	} else {
		prethodni = PreviousL(zadnji,L);
		prethodni->sljedeci = zadnji->sljedeci;
		delete zadnji;
		return 1;
	}
	return 0;
}
 
t_zivotinja RetrieveL(element p, t_lista *L){
	return p->zivotinja;
}
 
element DeleteAllL(t_lista *L){
	L->sljedeci = EndL(L);
}
 
t_lista* InitL(t_lista *L){	
	t_lista *zadnji = new t_lista;
	zadnji->sljedeci = NULL;
	L=new t_lista;
	L->sljedeci = zadnji;
	return L;
}
 
 
//lista_polja.h
#include <iostream>
#include <string.h>
#define MAXLENGTH 1000
#define OK 1
#define ERROR -1
using namespace std;
 
struct t_zivotinja{
	int sifra;
	char vrsta[20];
	char naziv[20];
	float cijena;
	unsigned int datum;
};
 
struct t_lista{
	t_zivotinja zivotinja[MAXLENGTH];
	int pokazivac;
};
 
typedef int element; //tip pokazivaca
 
element FirstL(t_lista *L){
	return 0;
}
 
element EndL(t_lista *L){
	return L->pokazivac;
}
 
element PreviousL(element p, t_lista *L){
	if(p == FirstL(L)) return ERROR;
	return p-1;
}
 
element NextL(element p, t_lista *L){
	if(p == EndL(L)) return ERROR;
	if(p == PreviousL(EndL(L),L)) return EndL(L);
	return p+1;
}
 
element LocateL(t_zivotinja x, t_lista *L){
	element p;
	for(p=0; p<EndL(L); p++)
		if(x.sifra==L->zivotinja[p].sifra || 
		!strcmp(L->zivotinja[p].naziv,x.naziv) || 
		!strcmp(L->zivotinja[p].vrsta,x.vrsta))
			return p;
	return EndL(L);
}
 
element InsertL(t_zivotinja x, element p, t_lista *L){
	for(int i=EndL(L); i>p; i--)
		L->zivotinja[i] = L->zivotinja[i-1];
	L->zivotinja[p] = x;
	L->pokazivac++;
	if(x.sifra==L->zivotinja[p].sifra) return OK;
	return ERROR;
}
 
element DeleteL(element p, t_lista *L){
	if(p == EndL(L)) return ERROR;
	int pokazivac_temp = L->pokazivac;
	for(int i=p; i<EndL(L); i++)
		L->zivotinja[i] = L->zivotinja[i+1];
	if(p != EndL(L)) L->pokazivac--;
	if(pokazivac_temp != L->pokazivac) return OK;
	return ERROR;
}
 
t_zivotinja RetrieveL(element p, t_lista *L){
	return L->zivotinja[p];
}
 
element DeleteAllL(t_lista *L){
	L->pokazivac = 0;
	return OK;
}
 
t_lista* InitL(t_lista *L){
	L = new t_lista;
	L->pokazivac = 0;
	return L;
}