#-*- coding: iso-8859-2 -*-
import socket, sys, os, codecs, getopt, select

def czyBledne(slowo):
    slowo_podpowiedzi=slowo.split(':') #podziel wiersz na slowo i podpowiedzi
    if len(slowo_podpowiedzi)==1: #nie ma podpowiedzi, slowo jest OK
        return False,slowo_podpowiedzi[0]
    else: #slowo bledne, ma podpowiedzi
        return True,slowo_podpowiedzi

#wczytywanie slownika z odpowiednim kodowaniem
def wczytaj_slownik(slownik, code):
    try:
        f=open(slownik, 'r')
    except IOError, inst:
        if inst.args[0]==2: #plik nie istnieje
            try:
                f=open(slownik, 'r+')
            except:
                sys.stderr.write("Blad odczytu pliku slownika.\n")
                sys.exit(1)
        else:
            sys.stderr.write("Blad odczytu pliku slownika:\n"+inst.args[1]+'\n')
            sys.exit(1)
    dict={}
    bledne={}
    try:
        key=f.readline().strip().decode(code)
    except: #cos nie tak z kodowaniem
        sys.stderr.write("Podano zle kodowanie do odczytu pliku slownika.\n")
        sys.exit(1)
    while key:
        zle,slowo=czyBledne(key)
        if not zle:
            dict[slowo]=""
        else:
            bledne[slowo[0]]=slowo[1].split(',')
        try:
            key=f.readline().strip().decode(code)
        except:
            sys.stderr.write("Podano zle kodowanie do odczytu pliku slownika.\n")
            sys.exit(1)
    f.close()
    return dict, bledne

#dodawanie/usuwanie slowa ze slownika
def dodaj(slowo, dict, bledne):
    if slowo[-1]==':': #usun slowo ze slownika
        if slowo.strip(':') in dict:
            del dict[slowo.strip(':')]
    else: #dodaj slowo
        zle, akt=czyBledne(slowo)
        if not zle:
            dict[akt]=""
        else:
            bledne[akt[0]]=akt[1].split(',')
    return dict, bledne

#funkcja do zapisania zmian do pliku slownika (uzywane przy wylaczaniu serwera)
def zapisz_zmiany(slownik, code, dict, bledne):
    try:
        f=open(slownik,'w')
    except:
        sys.stderr.write("Blad podczas otwierania slownika w celu zapisu. Zmiany nie zostaly zapisane!\n")
        return 1
    for key in dict:
        f.write(key.encode(code)+'\n') #wyjatek niepotrzebny - jezeli kodowanie zle to wywali przy starcie.
    for key in bledne:
        key=key.strip()
        f.write(key.encode(code)+":")
        for podp in bledne[key][:-1]:
            podp=podp.strip().encode(code)
            f.write(podp+',')
        f.write(bledne[key][-1].encode(code)+'\n')
    f.close()

try:
    opts, args=getopt.gnu_getopt(sys.argv[1:], "hf:e:", ["help"])
except getopt.error:
    sys.stderr.write("Blad argumentu.\n")
    sys.exit(1)

#ustawienie domyslnych wartosci

f=False
e=False
kodowanie="iso-8859-2"
slownik="slownik.txt"

for opt, arg in opts:
    if opt in ["-h", "--help"]:
        print "[X] Sposob uzycia:\n serwer.py [nr_portu] [-hf:e:]"
        print "[X] -h, --help:\n Wyswietla ten ekran pomocy."
        print "[X] -f [plik]:\n Wczytuje podany plik jako slownik (domyslnie slownik.txt)"
        print "[X] -e [kodowanie]:\n Do wczytania slownika zostanie uzyte podane kodowanie (domyslnie iso-8859-2)"
        sys.exit(0)
    elif opt=="-f":
        f=True
        slownik=arg
    elif opt=="-e":
        e=True
        kodowanie=arg


#start serwera

try:
    gniazdo=socket.socket()
    gniazdo.bind(("", int(args[0])))
    gniazdo.listen(5)
except socket.error, inst:
    if inst.args[0]==13: #permission denied
        sys.stderr.write("Nie mozna uruchomic serwera na podanym porcie.\n")
        sys.exit(1)
    else:
        sys.stderr.write("Blad podczas stawiania serwera: "+inst.args[1]+"\n")
        sys.exit(1)

dict, bledne=wczytaj_slownik(slownik, kodowanie)
print "Serwer dziala na slowniku "+slownik

readlist=[sys.stdin, gniazdo]
zapytania={}

while True:
    read_ready,_,_=select.select(readlist,[],[])
    for obiekt in read_ready:
        if obiekt==sys.stdin: #wpisujemy cos z poziomu serwera
            komenda=sys.stdin.readline().strip()
            if komenda=="exit":
                zapisz_zmiany(slownik, kodowanie, dict, bledne) #zapis do pliku przed wyjsciem
                for obiekt in readlist:
                    obiekt.close()
                sys.exit(0)
            elif komenda=="save": #zapisz slownik na dysku
                zapisz_zmiany(slownik, kodowanie, dict, bledne)
            else:
                print "Nieznana komenda."
        elif obiekt==gniazdo: #klient chce sie polaczyc
            klient,_=gniazdo.accept()
            readlist.append(klient)
            zapytania[klient]=""
        else: #obsluga polaczonego klienta
            zadanie=obiekt.recv(1024)
            if zadanie: #jezeli ma cos jeszcze do odebrania to dodaj do listy
                zapytania[obiekt]+=zadanie
            else:
                error=False #zmienna do sprawdzania czy wystapil wyjatek
                lista=zapytania[obiekt].split('\n')
                odpowiedz="ok " #co wysle serwer
                ile=0 #ile linii w odpowiedzi
                kontrolne_ile=0 #do sprawdzenia poprawnosci naglowka
                lista_odp=""
                #zczytaj naglowek i zinterpretuj
                try:
                    naglowek=lista[0].split(' ')
                    zadcode=naglowek[2] #kodowanie zadania
                except: #naglowek nie ma 3 skladowych
                    error=True
                    odpowiedz="error 0"
                    obiekt.sendall(odpowiedz)
                if not error:
                    if naglowek[0]=="check": #sprawdzanie
                        for slowo in lista[1:]:
                            kontrolne_ile+=1
                            if not error:
                                if kontrolne_ile>int(naglowek[1]): #przeslano wieksza ilosc slow niz zadeklarowano w naglowku
                                    error=True
                                    odpowiedz="error 1"
                                    obiekt.sendall(odpowiedz)
                                else:
                                    try:
                                        slowocode=slowo.decode(zadcode) #zadanie dekodujemy do unikodu
                                    except LookupError: #nieznane kodowanie
                                        error=True
                                        odpowiedz="error 0"
                                        obiekt.sendall(odpowiedz)
                                    except UnicodeDecodeError: #zle kodowanie
                                        error=True
                                        odpowiedz="error 1"
                                        obiekt.sendall(odpowiedz)
                                    if not error:
                                        if slowocode in dict:
                                            pass
                                        elif slowocode in bledne: #czy slowo jest bledne i ma podpowiedzi?
                                            ile+=1
                                            lista_odp+=slowocode.strip()+":"
                                            for podp in bledne[slowocode]:
                                                lista_odp+=podp.strip()+","
                                            lista_odp=lista_odp.strip(',') #kasujemy niepotrzebny przecinek
                                            lista_odp+='\n'
                                        else: #slowo bledne, bez podpowiedzi
                                            ile+=1
                                            lista_odp+=slowocode.strip()+'\n'
                        #skladanie odpowiedzi
                        if not error:
                            if kontrolne_ile<int(naglowek[1]): #przeslano mniej wyrazow niz zadeklarowano
                                odpowiedz="error 1"
                                obiekt.sendall(odpowiedz)
                            else:
                                odpowiedz+=str(ile)+'\n'
                                odpowiedz+=lista_odp
                                odpowiedz=odpowiedz.strip()
                                try: #zle kodowanie
                                    odpowiedz=odpowiedz.encode(zadcode)
                                except:
                                    odpowiedz="error 1"
                                obiekt.sendall(odpowiedz) #odsylamy zadanie
                    elif naglowek[0]=="add": #dodawanie
                        for slowo in lista[1:]:
                            kontrolne_ile+=1
                            if kontrolne_ile>int(naglowek[1]): #przeslano wieksza ilosc slow niz zadeklarowano w naglowku
                                error=True
                                odpowiedz="error 1"
                                obiekt.sendall(odpowiedz)
                            else:
                                try:
                                    slowocode=slowo.decode(zadcode)
                                except LookupError: #nieznane kodowanie
                                    error=True
                                    odpowiedz="error 0"
                                    obiekt.sendall(odpowiedz)
                                except UnicodeDecodeError: #zle kodowanie
                                    error=True
                                    odpowiedz="error 1"
                                    obiekt.sendall(odpowiedz)
                                if not error:
                                    if slowocode in dict: #slowo w slowniku - pomijamy dodawanie
                                        pass
                                    else: #dodaj do slownika
                                        dict,bledne=dodaj(slowocode, dict, bledne)
                        if not error:
                            if kontrolne_ile<int(naglowek[1]): #przeslano mniej wyrazow niz zadeklarowano
                                odpowiedz="error 1"
                                obiekt.sendall(odpowiedz)
                            else:
                                odpowiedz+=str(ile)+'\n'
                                try:
                                    odpowiedz=odpowiedz.encode(zadcode)
                                except:
                                    odpowiedz="error 1"
                                obiekt.sendall(odpowiedz)
                    else: #nieprawidlowe polecenie
                        odpowiedz="error 0"
                        obiekt.sendall(odpowiedz)
                del zapytania[obiekt]
                readlist.remove(obiekt)
                obiekt.close()