/*================================================================
*   Copyright (C) 2021 ChenXuandong Ltd. All rights reserved.
*
*   FileName:avltree.cpp
*   Author:ChenXuandong
*   Data:2021年01月05日
*   Description：
*
================================================================*/
#include <iostream>
#include <string.h>
#include <cmath>
#include <time.h>
#include <list>
#include <fcntl.h>
#include <iostream>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#define TCP_PORT_NUMBER 5555
#define NUM_CONNECTIONS 2
#define MAX_SIZE 32727
using namespace std;
int connections[NUM_CONNECTIONS];
struct sockaddr_in clients[NUM_CONNECTIONS];
int num_connected=0;
const int num_stud = 20;
int Index = 0;
int allneednom[num_stud];
int nom_del = -1;
char commands[25][20];

long int RndDouble(){
	int num;
	long int totalNum = 0;
	for(int j = 0; j < 6; j++){
		num = rand() % 10;
		totalNum += num * pow(10, j);
	}
	return totalNum;
}

char RndCaps(){ return (char)(rand()%26+'A'); }

char RndLitt(){ return (char)(rand()%26+'a'); }

int RndDiap(int nMin, int nMax){ return rand()%(nMax-nMin)+nMin; }

bool Menshe(string s1, string s2){ return s1 < s2; }

int analyse_commands(char buf[MAX_SIZE]){
	int num=0,row=0,col=0;
	int len=strlen(buf);
	for (; row<len; row++){
		if (buf[row]!= ' ')
			commands[num][col++]=buf[row];
		else{
			if(col!=0){
				commands[num++][col]='\0';
				col=0;
			}
		}
	}
	if(col!=0) commands[num++][col]='\0';
	for(int i=num; i<25; i++) commands[i][0]='\0';
	return num;
}

int getindex_afterspace_untilnextword(char* str){
	int len = strlen(str);
	for(int i=0; i<len; i++){
		if(str[i]=='\n' || str[i]=='\0') return i;
		if(str[i]==' ') if(str[i+1]!=' ' && str[i+1]!='\n' && str[i+1]!='\0') return i;
	}
	return len;
}

char* cutout_str_first_word(char* str){
	int index1 = getindex_afterspace_untilnextword(str);
	if(str[index1]=='\n') return NULL;
	char* struse4 = (char*)malloc((strlen(str) - index1-1)*sizeof(char));
	strncpy( struse4, str+index1+1, strlen(str)-index1-1);
	struse4[strlen(str)-index1-1]='\0';
	return struse4;
}

char* getnextword(char* str){
	int index1 = getindex_afterspace_untilnextword(str);
	if(str[index1]=='\n')
		return str;
	int index2 = getindex_afterspace_untilnextword(str+index1+1);
	char* struse4 = (char*)malloc((index2)*sizeof(char));
	strncpy(struse4, str+index1+1, index2);
	struse4[index2]='\0';
	return struse4;
}

class Fio {
private:
	string sFio;
public:
	Fio(){}
	Fio(string str){ sFio = str; }
	Fio(const Fio& fio){ this->sFio=fio.sFio; }
	void RndInit();
	string GetString(){ return sFio; }
	void SetsFio(string str){ sFio = str; }
	friend ostream& operator<< (ostream& os, const Fio& fio);
	friend bool operator == (const Fio& fio1, const Fio& fio2);
	friend bool operator < (const Fio& fio1, const Fio& fio2);
	friend bool operator > (const Fio& fio1, const Fio& fio2);
};

void Fio::RndInit(){
	string fnames[6] = {"Mihailof","Kyznecof","Smirnof","Vacilief","Bobof","Bitrof"};
	string names[9] = {"Anton","Vektoliy","Yuli","Lef","Oleg","Alex","Sasha","Ivan","Vacia"};
	sFio = fnames[rand()%6]+names[rand()%9]+names[rand()%9];
}

bool operator == (const Fio& fio1, const Fio& fio2){
	if( fio1.sFio.length() != fio2.sFio.length() ) return false;
	int len = fio1.sFio.length();
	for(int i=0; i<len; i++){
		if(fio1.sFio[i]==fio2.sFio[i]) continue;
		else return false;
	}
	return true;
}

bool operator < (const Fio& fio1, const Fio& fio2){
	int len = min( fio1.sFio.length(), fio2.sFio.length() );
	for(int i=0; i<len; i++){
		if(fio1.sFio[i]==fio2.sFio[i]) continue;
		else if(fio1.sFio[i]<fio2.sFio[i]) return true;
		else return false;
	}
	return fio1.sFio.length() < fio2.sFio.length();
}

bool operator > (const Fio& fio1, const Fio& fio2){
	int len = min( fio1.sFio.length(), fio2.sFio.length() );
	for(int i=0; i<len; i++){
		if(fio1.sFio[i]==fio2.sFio[i]) continue;
		else if(fio1.sFio[i]>fio2.sFio[i]) return true;
		else return false;
	}
	return fio1.sFio.length() > fio2.sFio.length();
}

ostream& operator<< (ostream& os, const Fio& fio){
    os<<fio.sFio;
    return os;
}

class Student {
private:
	Fio fio;
	long int rRating;
	string country;
	int age;
	string gender;
	int group;
public:
	Student();
	void RndInit();
	Fio& GetFio(){ return fio; }
	long int GetRating(){ return rRating; }
	int Getage(){ return age; }
	string Getcountry(){ return country; }
	string Getgender(){ return gender; }
	int Getgroup(){ return group; }
	void SetFio(Fio f){ fio = f; }
	void SetRating(long int r){ rRating = r; }
	void Setage(int a){ age = a; }
	void Setcountry(string c){ country = c; }
	void Setgender(string g){ gender = g; }
	void Setgroup(int g){ group = g; }
	friend ostream& operator<< (ostream& os, const Student& stud);
};

Student::Student(){
	fio.SetsFio( "Null" );
	rRating = 0;
	country = "Null";
	age = 0;
	gender = "Null";
	group = 0;
}

void Student::RndInit(){
	fio.RndInit();
	age = rand()%14+16;
	string genders[2]={"Male", "Female"};
	gender = genders[rand()%2];
	group = rand()%4+1;
	string countrys[8]={"China", "Russian", "USA", "Japan", "Korean", "UK", "France", "German"};
	country = countrys[rand()%8];
	rRating = RndDouble();
}

ostream& operator<< (ostream& os, const Student& stud){
	os<<"Rating: "<<stud.rRating;
	os<<"   fio: "<<stud.fio;
	os<<"   country: "<<stud.country;
	os<<"   age: "<<stud.age;
	os<<"   gender: "<<stud.gender;
	os<<"   group: "<<stud.group;
	os<<endl;
	return os;
}

const int NALL=32767;

class StudentsAll {
private:
	int nKol;
	Student students[NALL];
public:
	StudentsAll(){ nKol=0; }
	void RndInit(int n);
	int GetKol(){ return nKol; }
	Student Getstudents(int i){ return students[i]; }
	Fio GetFio(int i){ return students[i].GetFio(); }
	long int GetRating(int i){ return students[i].GetRating(); }
	string Getcountry(int i){ return students[i].Getcountry(); }
	int Getage(int i){ return students[i].Getage(); }
	string Getgender(int i){ return students[i].Getgender(); }
	int Getgroup(int i){ return students[i].Getgroup(); }
	bool Add(Student& st);
	bool Del(int nom);
	void Print(int i);
};

void StudentsAll::RndInit(int n){
	for(int i=0; i<n; i++)
		students[i].RndInit();
	nKol = n;
}

bool StudentsAll::Add(Student& st){
	students[nKol] = st;
	nKol++;
	return true;
}

bool StudentsAll::Del(int nom){
	for(int i=nom; i<nKol-1; i++)
		students[i] = students[i+1];
	nKol--;
	return true;
}

void StudentsAll::Print(int i){	cout << students[i]; }

template < class Key > class AVLTree {
private:
	int nDepth;
    Key* pKey;
	int Nom;
    AVLTree* Parent;
	AVLTree* Left;
    AVLTree* Right;
public:
	AVLTree();
    AVLTree(AVLTree& AT);
    AVLTree(AVLTree* pAT);
    ~AVLTree();
    bool Del(Key* AAA, AVLTree*& AT);
    bool Del_Nom(Key* AAA, AVLTree*& AT);
	int Getdepth() { return nDepth; }
    void Setdepth(int ddd){ nDepth = ddd; }
	int GetNom(){ return Nom; }
	Key* GetKey(){ return pKey; }
	AVLTree* GetLeft(){ return Left; }
	AVLTree* GetRight(){ return Right; }
	AVLTree* ProtoMin();
    AVLTree* ProtoMax();
	void LL();
    void RR();
    bool Add(Key *pk, int nom);
	void Updata_Nom();
    void Print(int Space, int SpaceR);
	void Search(Key *pk);
	bool OneCheck();
};

template < class Key >
AVLTree<Key>::AVLTree(){
	nDepth = -1;
	Left = nullptr;
	Right = nullptr;
}

template < class Key >
AVLTree<Key>::AVLTree(AVLTree& AT){
    nDepth = AT.nDepth;
    if(nDepth<0) return;
    pKey = AT.pKey;
	Nom = AT.Nom;
	Left = new AVLTree(*AT.Left);
	Right = new AVLTree(*AT.Right);
}

template < class Key >
AVLTree<Key>::AVLTree(AVLTree* pAT){
    nDepth = pAT->nDepth;
    if(nDepth<0) return;
    pKey = pAT->pKey;
	Nom = pAT->Nom;
    Left=new AVLTree(pAT->Left);
    Right=new AVLTree(pAT->Right);
}

template < class Key >
AVLTree<Key>::~AVLTree(){
    if(nDepth<0) return;
    delete Left;
    delete Right;
}

template < class Key >
AVLTree<Key>* AVLTree<Key>::ProtoMin(){
    if(Left->Left->nDepth<0) return this;
    return Left->ProtoMin();
}

template < class Key >
AVLTree<Key>* AVLTree<Key>::ProtoMax(){
    if(Right->nDepth<0) return this;
    return Right->ProtoMax();
}

template < class Key >
void AVLTree<Key>::Updata_Nom(){
    if(nDepth<0) return;
	if(nom_del<Nom) Nom--;
	Left->Updata_Nom();
	Right->Updata_Nom();
}

template < class Key >
bool AVLTree<Key>::Del_Nom(Key* AAA, AVLTree*& AT){
    if(AT->nDepth<0) return false;
	if(*AAA<*pKey){
        if(AT->Left->Del_Nom(AAA,AT->Left)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==-2)
                if(AT->Right->Left->Getdepth()-AT->Right->Right->Getdepth()==-1) AT->RR();
                else
                {
                    AT->Right->LL();
                    AT->RR();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
    }
    else if(*pKey<*AAA){
        if(AT->Right->Del_Nom(AAA,AT->Right)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==2)
                if(AT->Left->Left->Getdepth()-AT->Left->Right->Getdepth()==1) AT->LL();
                else
                {
                    AT->Left->RR();
                    AT->LL();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
    }
	else if(Nom == nom_del){

    if(AT->Left->nDepth<0&&AT->Right->nDepth<0){
        AT->nDepth--;
        delete Left;
        delete Right;
        return true;
    }
    else if(AT->Right->nDepth<0){
		AT=AT->Left;
        return true;
    }
    else if(AT->Left->nDepth<0){
		AT=AT->Right;
        return true;
    }
	else{
	    AT->pKey = AT->Left->ProtoMax()->pKey;
		AT->Nom = AT->Left->ProtoMax()->Nom;
        AT->Left->ProtoMax()->Nom = nom_del;
        if(AT->Left->Del_Nom(AT->pKey,AT->Left)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==-2)
                if(AT->Right->Left->Getdepth()-AT->Right->Right->Getdepth()==-1) AT->RR();
                else
                {
                    AT->Right->LL();
                    AT->RR();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
	}
	}else{
		if( AT->Left->OneCheck() ){
		if( AT->Left->Del_Nom(AAA, AT->Left) ){
			if(AT->Left->Getdepth()-AT->Right->Getdepth()==-2)
				if(AT->Right->Left->Getdepth()-AT->Right->Right->Getdepth()==-1) AT->RR();
				else
				{
					AT->Right->LL();
					AT->RR();
				}
			AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
			return true;
		}
		else return false;
		}
		else {
		if( AT->Right->Del_Nom(AAA, AT->Right) ){
			if(AT->Left->Getdepth()-AT->Right->Getdepth()==2)
				if(AT->Left->Left->Getdepth()-AT->Left->Right->Getdepth()==1) AT->LL();
				else
				{
					AT->Left->RR();
					AT->LL();
				}
			AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
			return true;
		}
		else return false;
		}
	}
}

template < class Key >
bool AVLTree<Key>::Del(Key* AAA, AVLTree*& AT){
    if(AT->nDepth<0) return false;
	else if(*pKey>*AAA){
        if(AT->Left->Del(AAA,AT->Left)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==-2)
                if(AT->Right->Left->Getdepth()-AT->Right->Right->Getdepth()==-1) AT->RR();
                else
                {
                    AT->Right->LL();
                    AT->RR();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
    }
    else if(*pKey<*AAA){
        if(AT->Right->Del(AAA,AT->Right)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==2)
                if(AT->Left->Left->Getdepth()-AT->Left->Right->Getdepth()==1) AT->LL();
                else
                {
                    AT->Left->RR();
                    AT->LL();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
    }
    else if(AT->Left->nDepth<0&&AT->Right->nDepth<0){
        AT->nDepth--;
		if(nom_del == -1)
			nom_del = Nom;
        delete Left;
        delete Right;
        return true;
    }
    else if(AT->Right->nDepth<0){
        if(nom_del == -1)
			nom_del = Nom;
		AT=AT->Left;
        return true;
    }
    else if(AT->Left->nDepth<0){
        if(nom_del == -1)
			nom_del = Nom;
		AT=AT->Right;
        return true;
    }
    else{
		if(nom_del == -1)
			nom_del = Nom;
	    AT->pKey = AT->Left->ProtoMax()->pKey;
		AT->Nom = AT->Left->ProtoMax()->Nom;
        if(AT->Left->Del(AT->pKey,AT->Left)){
            if(AT->Left->Getdepth()-AT->Right->Getdepth()==-2)
                if(AT->Right->Left->Getdepth()-AT->Right->Right->Getdepth()==-1) AT->RR();
                else
                {
                    AT->Right->LL();
                    AT->RR();
                }
            AT->nDepth=max(AT->Left->Getdepth(),AT->Right->Getdepth())+1;
            return true;
        }
        else return false;
	}
}

template < class Key >
void AVLTree<Key>::LL(){
	AVLTree* tr = new AVLTree(*this);
	AVLTree* tl = new AVLTree(Left);
	delete tr->Left;
	tr->Left = tl->Right;
    tr->nDepth = max( tr->Left->Getdepth(), tr->Right->Getdepth() )+1;
    pKey = Left->pKey;
	Nom = Left->Nom;
	delete Left;
	delete Right;
	Left = new AVLTree(tl->Left);
	Right = new AVLTree(tr);
	nDepth = max(Left->Getdepth(), Right->Getdepth())+1;
}

template <class Key>
void AVLTree<Key>::RR(){
	AVLTree* tr = new AVLTree(Right);
	AVLTree* tl = new AVLTree(*this);
	delete tl->Right;
	tl->Right = tr->Left;
    tl->nDepth=max( tl->Left->Getdepth(), tl->Right->Getdepth() )+1;
    pKey = Right->pKey;
	Nom = Right->Nom;
	delete Left;
	delete Right;
	Left = new AVLTree(tl);
	Right = new AVLTree(tr->Right);
	nDepth = max(Left->Getdepth(),Right->Getdepth())+1;
}

template <class Key>
bool AVLTree<Key>::Add(Key *pk, int nom)
{
    if(nDepth<0){
        nDepth++;
        pKey = pk;
	    Nom = nom;
        Left = new AVLTree;
        Right = new AVLTree;
        return true;
    }
	if(*pk < *pKey){
        if( !Left->Add(pk, nom) ) return false;
        else if( Left->Getdepth() - Right->Getdepth() == 2 )
            if( Left->Left->Getdepth() - Left->Right->Getdepth() == 1 ) LL();
            else
            {
                Left->RR();
                LL();
            }
    }
    else {
        if( !Right->Add(pk, nom) ) return false;
        else if( Left->Getdepth() - Right->Getdepth() == -2 )
            if( Right->Left->Getdepth() - Right->Right->Getdepth() == -1 ) RR();
            else
            {
                Right->LL();
                RR();
            }
    }
    nDepth = max( Left->Getdepth(), Right->Getdepth()) +1;
    return true;
}

template < class Key >
void AVLTree<Key>::Print(int Space, int SpaceR)
{
    if(nDepth<0) return;
    for(int i=0; i<Space; i++) cout<<" ";
    cout.width(3);
	cout << *pKey;
//	cout <<"("<< Getdepth() <<")";
//  cout << "("<< GetNom() <<")";
	Left->Print(0, SpaceR+6);
    if(Left->nDepth<0) cout<<endl;
    Right->Print(SpaceR,SpaceR+6);
}

template < class Key >
bool AVLTree<Key>::OneCheck(){
    if(nDepth<0) return false;
    if(nom_del == Nom) return true;
	else return Right->OneCheck() || Left->OneCheck();
}

template < class Key >
void AVLTree<Key>::Search(Key* pk){
    if(nDepth<0) return;
    if(*pKey == *pk){
		allneednom[Index] = this->Nom;
		Index++;
		Left->Search(pk);
		Right->Search(pk);
	}
	else if(*pk < *pKey)	Left->Search(pk);
		else Right->Search(pk);
}

int main(int argc, char** argv){
    int server_socket = socket(PF_INET, SOCK_STREAM, 0);
    if(server_socket == -1){
        cerr << "socket() error!" << endl;
        exit(-1);
    }
    struct sockaddr_in server_addr;
    int on = 1;
    setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    //server_addr.sin_port = htons(atoi(argv[1]));
	server_addr.sin_port = htons(TCP_PORT_NUMBER);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    if(bind(server_socket, (struct sockaddr*)&server_addr, sizeof server_addr)){
        cerr << "bind() error!" << endl;
        exit(-1);
    }
    if(listen(server_socket, 5)){
        cerr << "listen() error!" << endl;
        exit(-1);
    }
    int client_socket;
    while(1){
        if((client_socket = accept(server_socket, NULL, NULL)) < 0){
            cerr << "accept() error!" << endl;
            exit(1);
        }
        cout << "A new client is connected, and his socket is " << client_socket << endl;
	int itmp=0;
	AVLTree<string> *ATcountrys = new AVLTree<string>;
	AVLTree<long int> *ATratings = new AVLTree<long int>;
	AVLTree<Fio> *ATfios = new AVLTree<Fio>;
	AVLTree<string> *ATgenders = new AVLTree<string>;
	AVLTree<int> *ATages = new AVLTree<int>;
	AVLTree<int> *ATgroups = new AVLTree<int>;
	StudentsAll stall;
	Student tmpstud;
	string tmpcountrys[100];
	long int tmpratings[100];
	Fio tmpfios[100];
	string tmpgenders[100];
	int tmpages[100];
	int tmpgroups[100];
	for(itmp=0; itmp<num_stud; itmp++){
		tmpstud.RndInit();
		stall.Add(tmpstud);
		tmpcountrys[itmp] = stall.Getcountry(itmp);
		tmpratings[itmp] = stall.GetRating(itmp);
		tmpfios[itmp] = stall.GetFio(itmp);
		tmpgenders[itmp] = stall.Getgender(itmp);
		tmpages[itmp] = stall.Getage(itmp);
		tmpgroups[itmp] = stall.Getgroup(itmp);
		ATcountrys->Add(&tmpcountrys[itmp], itmp+1);
		ATratings->Add(&tmpratings[itmp], itmp+1);
		ATfios->Add(&tmpfios[itmp], itmp+1);
		ATgenders->Add(&tmpgenders[itmp], itmp+1);
		ATages->Add(&tmpages[itmp], itmp+1);
		ATgroups->Add(&tmpgroups[itmp], itmp+1);
	}
	char message[MAX_SIZE];
	char str[300]={0};
	char mes[MAX_SIZE];
	int numcom = 0;
	while(1){
		read(client_socket, str, sizeof(str));
		numcom = analyse_commands(str);
		if(!strncmp(commands[0], "SHOW",4) || !strncmp(commands[0], "FIND",4) )
		{
			int save_fd = dup(STDOUT_FILENO);
			int fd1 = open("out.txt",(O_RDWR | O_CREAT), 0644);
			dup2(fd1,STDOUT_FILENO);
			if(!strncmp(commands[0], "SHOW",4)) for(int i=0; i<stall.GetKol(); i++) stall.Print(i);
			else{
				if(!strncmp(commands[1],"\n",1)){
					strncpy(mes, "FIND ()\n",9);
				}else{
					string nextword = getnextword(str);
					for(int i=0; i<stall.GetKol(); i++)	allneednom[i] = -1;
					Index=0;
					if(!strncmp(commands[1], "China",5) || !strncmp(commands[1],"Russian",7) || !strncmp(commands[1],"German",6) || !strncmp(commands[1],"Japan",5)|| !strncmp(commands[1],"Korean",6) || !strncmp(commands[1],"France",6) || !strncmp(commands[1],"USA",3) || !strncmp(commands[1],"UK",2) ){
						ATcountrys->Search(&nextword);
					}
					else if(!strncmp(commands[1], "Male",4) || !strncmp(commands[1], "Female",6)){
						ATgenders->Search(&nextword);
					}
					else if( !strncmp(commands[1],"Group",5) ){
						char* stmp = commands[2];
						int n = atoi( stmp );
						ATgroups->Search(&n);
					}
					else if( !strncmp(commands[1],"Age",3) ){
						char* stmp = commands[2];
						int n = atoi( stmp );
						ATages->Search(&n);
					}
					else if( !strncmp(commands[1],"Rating",6) ){
						long int n = atoi(commands[2]);
						ATratings->Search(&n);
					}
					else{
						strncpy(mes, "FIND (wrong)\n",14);
					}
					for(int i=0; i<num_stud; i++){
						if(allneednom[i]==-1) break;
						stall.Print(allneednom[i] - 1);
						allneednom[i] = -1;
					}
					Index = 0;
				}
			}
			close(fd1);
			dup2(save_fd,STDOUT_FILENO);
			FILE* fp1 = fopen("out.txt","r");
			char tmp;
			int m=0;
			for(m=0;;m++){
				tmp=fgetc(fp1);
				if(tmp==EOF) break;
				mes[m] = tmp;
			}
			mes[m] = '\0';
			fclose(fp1);
			remove("out.txt");
		}
		else if(!strncmp(commands[0], "QUIT",4))
			strncpy(mes, "  quiting...\n",13);
		else if(!strncmp(commands[0], "ADD",3) ){
			allneednom[0]=-1;
			Index = 0;
			if(commands[2][0]!='\0'){
				long int serrating = atoi( commands[2] );
				ATratings->Search(&serrating);
			}
			if( allneednom[0]!=-1 ){
				strncpy(mes,"have same rating can't add",26);
				for(int i=0; allneednom[i]!=-1; i++) allneednom[i] = -1;
				Index = 0;
			}else{
				int flag=0;
				if(strncmp(commands[1],"Rating",6)) flag=1;
				if(strncmp(commands[3],"Fio",3)) flag=1;
				if(strncmp(commands[5],"Country",7)) flag=1;
				if(strncmp(commands[7],"Age",3)) flag=1;
				if(strncmp(commands[9],"Gender",6)) flag=1;
				if(strncmp(commands[11],"Group",5)) flag=1;
				if(flag==1)	strncpy(mes,"not correct add",15);
				else{
					Student addstud;
					addstud.SetRating( atoi(commands[2]) );
					Fio afio(commands[4]);
					addstud.SetFio(afio);
					addstud.Setcountry(commands[6]);
					addstud.Setage( atoi(commands[8]) );
					addstud.Setgender(commands[10]);
					addstud.Setgroup( atoi(commands[12]) );
					stall.Add(addstud);
					int nowkol=stall.GetKol();
					tmpcountrys[itmp] = stall.Getcountry(nowkol-1);
					tmpratings[itmp] = stall.GetRating(nowkol-1);
					tmpfios[itmp] = stall.GetFio(nowkol-1);
					tmpgenders[itmp] = stall.Getgender(nowkol-1);
					tmpages[itmp] = stall.Getage(nowkol-1);
					tmpgroups[itmp] = stall.Getgroup(nowkol-1);
					ATcountrys->Add(&tmpcountrys[itmp], nowkol);
					ATratings->Add(&tmpratings[itmp], nowkol);
					ATfios->Add(&tmpfios[itmp], nowkol);
					ATgenders->Add(&tmpgenders[itmp], nowkol);
					ATages->Add(&tmpages[itmp], nowkol);
					ATgroups->Add(&tmpgroups[itmp], nowkol);
					itmp++;
					strncpy(mes, "success add", 11);
				}
			}
		}
		else if( !strncmp(commands[0], "DEL",3) ){
			if( !strncmp(commands[1],"Rating",6) ){
				allneednom[0]=-1;
				Index = 0;
				if(commands[2][0]!='\0'){
					long int serrating = atoi( commands[2] );
					ATratings->Search(&serrating);
				}
				if(allneednom[0]==-1 || commands[2][0]=='\0'){
					if(allneednom[0]==-1)
						strncpy(mes,"don't have this rating, can't del",33);
					else strncpy(mes,"no rating",9);
					for(int i=0; allneednom[i]!=-1; i++) allneednom[i] = -1;
					Index = 0;
				}else{

				long int num_rating = 0;
				long int flag = 1;
				num_rating = atoi(commands[2]);
				ATratings->Del(&num_rating, ATratings);
				ATratings->Updata_Nom();
				string c = stall.Getcountry(nom_del-1);
				Fio f = stall.GetFio(nom_del-1);
				string gen = stall.Getgender(nom_del-1);
				int a = stall.Getage(nom_del-1);
				int gr = stall.Getgroup(nom_del-1);
				ATages->Del_Nom(&a, ATages);
				ATfios->Del_Nom(&f, ATfios);
				ATgenders->Del_Nom(&gen, ATgenders);
				ATgroups->Del_Nom(&gr, ATgroups);
				ATcountrys->Del_Nom(&c, ATcountrys);
				ATages->Updata_Nom();
				ATfios->Updata_Nom();
				ATgenders->Updata_Nom();
				ATgroups->Updata_Nom();
				ATcountrys->Updata_Nom();
				stall.Del(nom_del-1);
				nom_del = -1;
				strncpy(mes,"success del",11);
				}
			}
			else strncpy(mes,"not correct del",15);
		}
		else{
			strncpy(mes, "not command",11);
		}
		write(client_socket, mes, sizeof(mes));
		memset(str,0,sizeof(str));
		memset(mes,0,sizeof(mes));
	}
	}
	close(client_socket);
    close(server_socket);
    return 0;
}