#!/usr/bin/perl -w
# spell.pl 0.5.0
# 
# Skriptas(imho jau išaugo iš "skriptuko" dydžio bei funkcionalumo) naujiems 
# lietuviškiems ispell žodynams sudarinėti. Skaito žodžius, ir jeigu neapibrėžti 
# jokie flagai, išsiaiškina, kokių reikia, bei išsaugo žodį /~ esančiuose žodynuose
# iš kurių, vėliau, kompiliuojamas pagrindinis ispell žodynas.
#
# Vartojimas:
# spell.pl                       # skaito žodžius iš klaviatūros
# spell.pl žodynas               # skaito iš failo žodynas
#
# Parašė Laimonas Vėbra <l.v@centras.lt> stipriai patobulinęs skriptą, kurį
# parašė Gediminas Paulauskas <menesis@delfi.lt>, patobulinęs skriptus iš
# Alberto Agejevo <alga@uosis.mif.vu.lt> bei Mariaus Gedmino <mgedmin@delfi.lt>. :)
# 
# TODO:
# * daugiau intelekto atspėjant žodžių formas
# * parametrais nurodomos įvesties/išvesties bylos 
# # ispell žodyno kompiliavimas
# # UI pagerinimas, galbūt .conf file'iukas
# # žodžių automatinio patikrinimo/kaupimo sistema susieta su http://doneaitis.vdu.lt resursais
# # yra minčių, sumanymų..
# #
# #
#             api ati
#             ap  at  į iš nu pa par per pra pri su už
# be nieko     a   b  c  d  e  f  g   h   i   j   k  l
# su sangrąža  m   n  o	 p  q  r  s   t   u   v   w  x
$SIG{INT} = \&sub_exit;  
$SIG{TERM} = \&sub_exit;
$SIG{KILL} = \&sub_exit;

%prefix = (
	   c => 'į',     d => 'iš',	e => 'nu',
	   f => 'pa',    g => 'par',    h => 'per',
	   i => 'pra',	 j => 'pri',	k => 'su',
	   l => 'už',	 m => 'apsi',	n => 'atsi',
	   o => 'įsi',	 p => 'išsi',	q => 'nusi',
	   r => 'pasi',	 s => 'parsi',	t => 'persi',
	   u => 'prasi', v => 'prisi',	w => 'susi',
	   x => 'užsi'
);
# filename hash
%fn_h = (
	 1 => 'lietuviu.daiktavardziai', 2 => 'lietuviu.vardai', 
	 3 => 'lietuviu.veiksmazodziai', 4 => 'lietuviu.budvardziai', 
	 5 => 'lietuviu.nekaitomi', 6 => 'lietuviu.ivairus', 
	 7 => 'lietuviu.jargon'
);
# file handle hash
%fh_h = (
	 1 => 'DAIKT', 2 => 'VARDAI', 
	 3 => 'VEIKS', 4 => 'BUDV',
	 5 => 'NEKAIT', 6 => 'IVAIR', 
	 7 => 'JARGON'
);

$versija = "spell.pl 0.5.0, parašė Laimonas Vėbra <l.v\@centras.lt>, 2002, Vilnius.";
# Escape sekos spalvotam rašymui
$G="\e[1;33m"; # geltona
#$Z="\e[1;32m"; # žalia
$R="\e[1;31m"; # raudona
#$M="\e[0;34m"; # mėlyna
$B="\e[1;37m"; # balta
$Y="\e[1;36m"; # žydra
#$V="\e[0;35m"; # violetinė
$d="\e[0;39m";  # pagrindinė(default)

#  @bkl_veiks_daikt_pries
#Būtojo kartinio laiko(bkl) formų šaknies balsį dažniausiai(su retomis išimtimis) turi šių priesagų veiksmažodiniai daiktavardžiai
#gyn-(imas) (: gynė) , myn-(ikas) (: mynė), ...
@bkl_veiks_daikt_pries=('imas','ikas','ėjas','ėja','yba','ykla','inys','iklis', 'oklis', 'ūnas','ūnė', 'ėlis','ėlė', 'ena', 'ėsis');

# @veiks_bendr_daikt_pries
# Bendraties šaknį turi šių priesagų daiktavardžiai
# -tuvas, -tuvė : vytuvas( :vyti), trintuvas (:trinti), durtuvas (: durti)
@veiks_bendr_daikt_pries=('tuvas','tuvė','tukas','tis','tas','tynė','klas','klė','klys');

local $found_u = 0; # ar žodis buvo rastas vartotojo ( (u)ser ) žodyne
local $found_i = 0; # ar žodis buvo rastas pagrindiniame, ispell'o ( (i)spell ) žodyne
local $flags;
local ($opt_b, $opt_B,  # force  black & white
       $opt_v, $opt_V,  # print version
       $opt_h, $opt_H,  # print usage(--help)
       $opt_p, $opt_P,  # PATH (jei žodynai yra ne /~ direktorijoje)
       $opt_f, $opt_F   # Tekstinis žodžių failas
);


# Komandinės eilutės argumentų tikrinimas
use Getopt::Std;

if( !getopts('bBvVhHp:P:f:F:') || @ARGV ) { 
    print "Įvyko klaida - neteisingai nurodyti argumentai.\nPeržiūrėkite ar programa buvo iškviesta teisingai?\n";
    exit;
}
else {
    if ($opt_b || $opt_B) {
	# Force Black & White. Sutinku, kad spalvos gali rėžti akį ar įkyrėti. TODO: custom colors
	$d = $Y = $R = $G = $B = '';
    }
    if($opt_v || $opt_V) { 
	print "$versija\n"; 
	exit;
    }
    if($opt_h || $opt_H) {
	&usage();
	exit;
    }
    
}

$pskirt = "$B"."====================$d\n"; # žodžio įvedimo (p)abaigos skiriamoji eilutė

&atidaryti_zodynus();

print "\n-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-\n";
print "Programa, nustatanti naujų žodžių afiksus ir rašanti žodžius į žodynus. \n";
print "Vėliau iš šių žodynų yra kompiliuojamas lietuvių kalbos $G"."ispell$d žodynas.\n";
print "    -$B Ctrl+D$d bet kada grįžta į programos pradžią.\n";
print "    -$B Ctrl+C$d bet kada nutraukia programos vykdymą.\n";
print "-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-\n";

$ARGV = '-'; # išankstinis nustatymas į STDIN

if($opt_f || $opt_F) { 
    $_ = defined($opt_f) ? $opt_f : $opt_F; 
    if(-e && -T) { $ARGV = $_; }
    else {
	print "$R"."Klaida$d, nėra tokio failo: $B$_$d, arba jis nėra tekstinis.\nBlogas programos rakto -(f|F) argumentas.\n"; 
	print "Nagrinėsiu jūsų įvedamus žodžius..\n";
    }
}

$KLAUSTI = $ARGV eq '-';
open (BYLA, $ARGV) or warn "Negaliu atidaryti $ARGV: $!\n";

# Pradedam..
&main();

sub main() {
    my $msg;
    my $main_msg = "\nĮveskite žodį ($G\^D$B baigti$d\, $G"."?$B pagalba$d\): $B";
    print  $main_msg if $KLAUSTI;
    
    while ($word = <BYLA>) {{
	if ($word =~ /^[\s\#]+/) { next; } 
	elsif($word =~ /.\/./) { # komentarai, tuščios eilutės bei žodžiai su flag'ais
	    chomp($word);
	    print "$word - jau turi afiksus.\n";
	    next;
	}

	chomp $word;
	print "$B$word$d\n";
	print "$d";
	if (!legal ($word)) { next; }  
	$flags = '';
	
	if ($word =~ /\?/) { pagalba(); next; }
	elsif ($word =~ /q/i) { sub_exit(); }
	
	$msg = "Tai $G"."d$d"."aiktavardis, $G"."v$d"."eiksmažodis, $G"."b$d"."ūdvardis,\n$G"."n$d"."ekaitomas žodis ar $G"."j$d"."argon? ($G"."d$d\/$G"."v$d\/$G"."b$d\/$G"."n$d\/$G"."j$d)";
	do  {
	    if(!ivesti_zodi($msg, 'j')) { next; }
	} until (/^[bdnvjq\?]$/i);
	
	if    (/v/i) { veiksmazodis($word); }
	elsif (/d/i) { daiktavardis($word); }
	elsif (/b/i) { budvardis($word); }
	elsif (/n/i) { nekaitomas($word); }
	elsif (/j/i) { jargon($word); }
	if(($found_u || $found_i) && $ARGV ne '-') { print "Norėdami tęsti paspauskite $B\"Enter\"$d klavišą..."; $_ = <STDIN>; }
    
    }
    print $main_msg if $KLAUSTI;
    }
}  

sub veiksmazodis {
    my ($bend, $es, $but);
    my ($msg, $ats);
    my $p_found_i = 0; #partial found - pagr. žodyne rasta viena ar kelios šakninės veiksmažodžio formos 

    print "$Y"."=== Veiksmažodis ===\n$B$word$d\n";
    $msg = "Įveskite veiksmažodžio bendratį($G"."ką daryti$d\/$G"."veikti?$d\)";
    do {
	if(! ($bend = ivesti_zodi($msg, ($word =~/.*tis?$/i) ? $word : '' )) ) { return; }
	elsif(!($bend =~ /.*tis?$/i)) { print "\n$R"."Dėmesio$d\, veiksmažodžio bendratis turi baigtis galūne \'$G"."-ti(s)$d\' !\n"; }
    }until ($bend =~/.*tis?$/i);
    
    $msg =  "Įveskite veiksmažodžio esamąjį laiką($G"."ką daro$d\/$G"."veikia?$d\)";
    if(! ($es = ivesti_zodi($msg, ($word =~/.*(a|[^t]i)$/i) ? $word : '' )) ) { return; };
    
    $msg = "Įveskite veiksmažodžio būtąjį kartinį laiką ($G"."ką darė$d\/$G"."veikė?$d\)";
    if(! ($but = ivesti_zodi($msg, ($word =~/.*ė$/i) ? $word : '')) ) { return; } 

    my %v_h = (1 => $bend, 2 => $es, 3 => $but); # pagrindinių (v)eiksmažodžio formų (h)ash
    my %vr_h = (1 => 0, 2 => 0, 3 => 0); # (v)eiksmažodžio forma (r)asta hash
    
    foreach $i (1,2,3) {
	&paieska_zodynuose($v_h{$i}, 2);  
	if($found_i || $found_u) { $p_found_i=1; $vr_h{$i} = 1; }
    }
    if($p_found_i) {
	if($vr_h{1} && $vr_h{2} && $vr_h{3}) { return; } 
	else {
	    print "\n\nJūsų įvestų veiksmažodžių:\n";
	    foreach $i (1,2,3) { 
		if(!$vr_h{$i}) {  print "$B$v_h{$i}$d\n"; }
	    }
	    print "$R"."nėra$d pagrindiniame ispell žodyne.\n\n";
	    print "Labai tikėtina, kad šie, jūsų įvesti, veiksmažodžiai yra neteisingi, o\npagrindiniame žodyne yra saugomos teisingos veiksmažodžio formos(bendratis,\nesamasis bei būtasis kartinis laikai).\n\n";
	    print "$B"."Kitavertus$d - neatmetama galimybė, kad pagrindiniame ispell žodyne yra klaida.\n";
	    print "Jei manote, kad tai yra žodyno klaida -  būkite malonūs, $B"."praneškite$d\napie tai žodyno bazės koordinatoriui.\n";
	    return;
	}	
    }
    elsif($found_u) {
	# TODO :
	return;
    }
    if(!veiks_tikrinimas(\$bend, \$es, \$but)) { return; }
    foreach $i (keys (%prefix), 'a[pt]', 'a[pt]i') {
        $prefix = ($i =~ /^a\[/) ? $i : $prefix{$i};
        next unless ($bend =~ /^$prefix(.*)/); 
        local $sb = $1;
        next unless ($es =~ /^$prefix(.*)/); 
        local $se = $1;
        next unless ($but =~ /^$prefix(.*)/); 
        local $su = $1;
	$msg = "$R"."Dėmesio$d\, gali būti, kad jūsų įvestas veiksmažodžis turi trumpesnę(be priešdėlių)\npamatinę formą)\nAr teisinga: $sb, $se, $su?";
	$ats = taip_ne ($msg, "t");
	if(!$ats) {  return; }
	elsif($ats == 1) {   
	    print "Toliau nagrinėsim veiksmažodžius: $sb, $se, $su\n";
	    $bend = $sb; $es = $se; $but = $su;
	    return;
	}
    }
    if (!append_flags("${bend}s, ${es}si, ${but}si?", 't', 'SX', 'NX')) { return; }
    
    $pref = ($bend =~ /^[bp]/i) ? 'api' : 'ap';
    if (!append_flags("$pref$bend, $pref$es, $pref$but?", 't', 'a')) { return; }
    
    $pref = ($bend =~ /^[dt]/i) ? 'ati' : 'at';
    if (!append_flags("$pref$bend, $pref$es, $pref$but?", 't', 'b')) {  return; }
    
    foreach $i (sort keys %prefix) {
        $pref = $prefix{$i};
        if (!append_flags("$pref$bend, $pref$es, $pref$but?", 't', "$i")) {  return; }
    }

    if ($bend =~ /[ūy]ti$/i and  $es =~ /[ūy].a$/i and $but =~ /[ui].o$/i) {
        $bf = "U";
    } else {
        $bf = "T";
    }

    $word = "$bend/$bf$flags\n";
    $word .= "$es/E$flags\n";
    if ($bend =~ /yti$/i){
	$word .= "but/Y$flags\n";
    } else {
	$word .= "$but/P$flags\n";
    }
    if ($flags =~ /S/) {
        $word .= "${bend}s/$bf\n";
        $word .= "${es}si/E\n";
        if ($bend =~ /yti$/i){
            $word .= "${but}si/Y";
        } else {
    	    $word .= "${but}si/P";
        }
    }
    print $pskirt;
    print "$word\n";
    irasyti_izodyna(2, $word);
    
}  # veiksmažodžio pabaiga

sub daiktavardis() {
    my $word = shift;
    my $msg;
    my $ats;
    print "\n=== $Y"."Daiktavardis$d ===\n$B$word$d\n";
    $msg = "Įveskite vardininko laipsnį ($G"."kas?$d\)";
    do {
	if (! ($word = ivesti_zodi($msg, $word)) ) { return; }
    	elsif($word =~ /.*[^aėios]$/i) { print "\n$R"."Dėmesio$d\, daiktavardžio vardininko laipsnis turi baigtis raidėmis \'$G"."a,ė,i,o,s$d\' !\n"; }
    } until( $word =~ /.*[aėios]$/i );    

    &paieska_zodynuose($word, 1);
    if($found_i) { return; }
    elsif($found_u)  { return; }  # TODO 

    # Patikrinimas ar teisingai rašomi veiksmažodinių daiktavardžių šaknies balsiai #
    my $pries_id = 0;
    foreach (@bkl_veiks_daikt_pries) {
	if ($word =~ /.*$_$/i) { 
	    $pries_id = 1;
	    last;
	}
    }
    foreach (@veiks_bendr_daikt_pries) {
	if ($word =~ /.*$_$/i) { 
	    $pries_id = 2;
	    last;
	}
    }
    if ($pries_id && !daikt_teisingas_balsis($word, $pries_id)) {  return; }
    ##
		
    if ($word !~ /(.*)(is|uo)$/i) {
        $flags = 'D'
    } else {
        my ($sak, $gal) = ($1, $2);
	$sak =~ s/t$/č/;
    	$sak =~ s/d$/dž/;
	$ats = taip_ne('Ar žodis yra vyriškos giminės?', 't');
	if(!$ats) {  return; }
       	if ($gal =~ /is/i && $ats == 1) {
	    # panašu, kad visi vyriškos gim. daiktavardžiai su galūne *.is  vns. kilmininko laipsnyje turi galunę *.io, todėl klausimas(žr. žemiau) yra nereikalingas
	    # taip_ne ("Ar vienaskaitos kilmininko($G"."ko?$d\) linksnis yra \'$B${sak}io$d\'\?", "t")) {
	    $flags = 'D'
    	} else {
            $flags = ($ats == 1) ? 'V' : 'M';
            $msg = "Ar galūnė minkšta - daugiskaitos kilminiko($G"."ko?$d\) laipsnis yra \'$B${sak}ių$d\'?";
	    if (!append_flags($msg, 't', 'I', 'K')) {  return; }
    	}
    }
    if(!append_flags("Ar yra toks daiktas ne$word?", 'n', 'N')) {  return; }
    $word = "$word/$flags";
    print $pskirt;
    print "$word\n";
    irasyti_izodyna(1, $word);
}  # daiktavardžio pabaiga

sub budvardis {
    my ($kokyb, $ivardz);
    my $msg;
    my $ats;

    $word = $_[0];
    print "\n==== $Y"." Būdvardis$d =====\n$B$word$d\n";
    $msg = "Įveskite vardininko laipsnį ($G"."kas?$d\)";  
    do {
	if (! ($word = ivesti_zodi($msg, $word)) ) {  return; }
	if($word =~ /.*[^s]$/i) { print "\n$R"."Dėmesio$d\, būdvardžio vardininko laipsnis turi baigtis raide \'$G"."s$d\' !\n"; }
    } until( $word =~ /.*s$/i );    

    &paieska_zodynuose($word, 3);
    if($found_i) { return; }
    elsif ($found_u) { return; } # TODO

    $word =~ /(.*)(.)s$/i;
    $kokyb = $2 ne 'i';
    $msg = "Ar tai kokybinis būdvardis (kaip $1$2; ${word}is; turi laipsnius?)";
    if (! ($ats = append_flags($msg, 't', 'AQ')) ) {  return; }
    elsif($ats == 2) {
        my ($sak, $gal) = ($1, $2);
        $sak =~ s/t$/č/;
	$sak =~ s/d$/dž/;
        if(!append_flags("Ar tai santykinis būdvardis (kokiems - ${sak}iams)?", 't', 'B', 'A')) {  return; } 
    }
    # Albertas siūlo visiems būdvardžiams klijuoti /N
    #if(!append_flags("Ar gali būti ne$word?", 'n', 'N')) {  return; }
    $flags .= "N";
    $word = "$word/$flags";
    print $pskirt;
    print  "$word\n";
    irasyti_izodyna(3, "$word");
}  # būdvardžio pabaiga


sub nekaitomas {

    $word = $_[0];
    print "\n==== $Y"." Nekaitomas$d =====\n$B$word$d\n";
    &paieska_zodynuose($word, 4);
    if($found_i) { return; }
    elsif ($found_u) { return; } # TODO
    irasyti_izodyna(4, "$word");
}  # nekaitomas pabaiga

sub jargon {
    my $word = shift;
      
    print "\n=== $Y"."Žargonas$d ===\n$B$word$d\n";
    &paieska_zodynuose($word, 5);
    print "Jei tai kaitomas žodis, nurodykite afiksą ($G"."D,B,A...$d\): ";
    print "$B";
    $_ = <STDIN>;
    print "$d";
    chomp($_);
    if($_ ne '') { $word .= "\/$_"; } 
    irasyti_izodyna(5, "$word");
} # jargon pabaiga


sub legal {
    # Funkcija, kuri tikrina įvedamų žodžių "legalumą". Mano manymu, tai šiek tiek padeda išvengti klaidų ir sutaupyti laiko(pvz: vėlai pastebėjus, kad klaidingai 
    # įvestas žodis, reikia iš naujo pradėti procedūrą). 
    # Kitavertus, mano "užprogramuotas legalumas" (besikartojantys, sulipę priebalsiai(pvz.: ' kk','šš' ir t.t.), daugiau kaip trys  priebalsiai esantys greta
    # (pvz. : '.*ndžk.*'), gali būti klaidingas. Jei pastebėsite klaidas - praneškite <l.v@centras.lt>

    if ($word =~/^[^?q]$|.*([b,c,č,d,f-h,j-n,p-t,š,v,z,ą,č,ę,ė,į,ų,ū])\1+.*|.*[0-9]+.*|.*[wxq].+|.*[b,c,č,d,f-h,j-n,p-t,š,v,z,ž]{4,}.*/) {
	print	"\n$R"."Dėmesio$d, labai tikėtina, kad jūs įvedėte blogą žodį(jame negali būti skaičių,\n\"sulipusių\"(esančių greta) priebalsių bei kai kurių balsių, lotynų abėcėlės\nraidžių [q,w,x]..ir kt.)!\n";
	return 0;
    }
    else { return 1; }
}
## main() pabaiga ##
print "$d\nIki!\n";


sub daikt_teisingas_balsis($) {
    my $word = shift;
    my $id = shift;
    my $msg;
    if ($id == 1) {
	print "\n\n$R"."Dėmesio$d - tikėtina, kad žodis$B $word$d yra veiksmažodinis daiktavardis.\n"; 
	print "Tokie daiktavardžiai yra kilę iš veiksmažodžio(pvz. vytukas <- "; 
	print "vyti;\nirklas <- irti) ir savo šaknyje dažniausiai turi toki patį balsį\n";
	print "kaip ir pamatinio veiksmažodžio bendraties forma.\n\n";
	print "$Y"."Pvz:\n";
	print "\t$B\-tuvas:$d v$G"."y$d"."tuvas (: v$G"."y$d"."ti); tr$G"."i$d"."ntuvas (: tr$G"."i$d"."nti); d$G"."u$d"."rtuvas (: d$G"."u$d"."rti)...\n";
	print "\t$B\-tas:$d b$G"."u$d"."rtas (: b$G"."u$d"."rti); k$G"."e$d"."ltas (: k$G"."e$d"."lti); sv$G"."e$d"."rtas (: sv$G"."e$d"."rti)...\n";
	print "\t$B\-klė:$d b$G"."ū$d"."klė (: b$G"."ū$d"."ti); ž$G"."ū$d"."klė (: ž$G"."ū$d"."ti); v$G"."i$d"."ryklė (: v$G"."i$d"."rti)...\n\n";
    }
    elsif ($id == 2) {
	print "\n\n$R"."Dėmesio$d - tikėtina, kad žodis$B $word$d yra veiksmažodinis daiktavardis.\n"; 
	print "Tokie daiktavardžiai yra kilę iš veiksmažodžio(pvz. veikėjas <- "; 
	print "veikia,veikė;\nrašinys <- rašo,rašė) ir savo šaknyje dažniausiai turi toki patį balsį\n";
	print "kaip ir pamatinio veiksmažodžio būtojo kartinio laiko forma.\n\n";
	print "$Y"."Pvz:\n";
	print "\t$B\-imas:$d g$G"."y$d"."nimas (: g$G"."y$d"."nė); r$G"."i$d"."jimas (: r$G"."i$d"."jo); k$G"."ū$d"."limas (: k$G"."ū$d"."lė)...\n";
	print "\t$B\-inys:$d k$G"."ū$d"."rinys (: k$G"."ū$d"."rė); n$G"."ė$d"."rinys (: n$G"."ė$d"."rė); si$G"."u$d"."vinys (: si$G"."u$d"."vo)...\n";
	print "\t$B\-ėsis:$d gri$G"."u$d"."vėsis (: gri$G"."u$d"."vo); dži$G"."ū$d"."vėsis (: dži$G"."ū$d"."vo); p$G"."u$d"."vėsis (: p$G"."u$d"."vo)...\n\n";
    }
    $msg = "Pasitikrinkite ar daiktavardžio šaknyje yra teisingas balsis?";
    if ( !taip_ne($msg, "t")) {
	$msg = "Įveskite teisingą žodį ($G"."q$d sugrįžti į pradžią)";
	if (! ($word = ivesti_zodi($msg, $word)) ) {  return; };
    }
    return 1;
}

sub atidaryti_zodynus()
{
    use Fcntl qw(:DEFAULT :flock);
    my $home; 
    if($opt_p || $opt_P){
       	$_ = defined($opt_p) ? $opt_p : $opt_P;
	if(-d) {
	    if(/\/bin\/?.*|\/usr\/bin\/?.*|\/usr\/local\/bin\/?.*|\/sbin\/?.*|\/usr\/sbin\/?.*|\/usr\/X11R6\/?.*/) {
		print "$R"."Būtų neprotinga$d saugoti žodynų failus $B$_$d direktorijoje.\n";
		print "Jei jūs manote kitaip - fixme($0, ".(__LINE__ - 2)." eilutė)\n";
		print "Užsispyriau, toliau neveiksiu! ;)\n";
		exit;
	    }
	    else { $home = $_; }
	}
	else { print "$R"."Klaida$d, nėra tokios direktorijos: $B$_$d !\nBlogas programos rakto -(p|P) argumentas.\n"; exit; }
    }
    else{ $home = $ENV{"HOME"} || $ENV{"LOGDIR"} || (getpwuid($<))[7]; }
           
    foreach $key ( keys (%fn_h) ) {
	sysopen( $fh_h{$key},"$home/$fn_h{$key}", O_RDWR | O_APPEND |O_CREAT) or die "\$n$R"."Dėmesio$d\, negaliu atidaryti/sukurti /$home/$fn_h{$key} !";
	flock($fh_h{$key}, LOCK_EX) or die "\n$R"."Dėmesio$d\, negaliu užrakinti(lock) /$home/$fn_h{$key} !";    
    }

}
sub paieska_zodynuose($$) {
    my $word = shift;
    my $dalis_id = shift; # kokia kalbos dalis 1 - daiktavardis, 2 - veiksmažodis, 3 - būdvardis, 4 - nekaitoma
    my ($str1, $msg, $ats);
    my $af = '';
    $found_i = 0;
    # paieška pagrindiniame ispell žodyne #
    open(FROM_ISPELL, "echo $word | ispell -d lietuviu -a | grep \'^[*,-,+,&,#,?]\' |") or die 	"\n$R"."Dėmesio$d".", negaliu įvykdyti komandos \'echo $word | ispell -d lietuviu -a | grep \'^[*,-,+,&,#,?]\' \' !";
    $_ = <FROM_ISPELL>;
    close(FROM_ISPELL);
    if (/^\*/) {
	print "$R"."Dėmesio$d".", žodis $B\'$word\'$d yra pagrindiniame ispell žodyne.\n";
	$found_i = 1;
	return;
    }
    elsif ( /^\+.(.*)$/ ) {
	print "$R"."Dėmesio$d".", jūsų įvesta žodžio forma $B\'$word\'$d turi šakninį žodį $G\'$1\'$d,\nkuris  yra pagrindiniame ispell žodyne.\n";
	$found_i = 1;
	return;
    }
    ##	   
    
    # TODO: tikrinti abu žodynus(tiek sukompiliuotą, tiek vartotojo) ir ieškoti galimai pasikartojančių žodžių
    if ($dalis_id == 1) {
    # daiktavardžio paieška ~ direktorijoje esančiuose žodynuose #
	foreach $key (1,2) {
	    if(find_in($fh_h{$key}, $word)) {
		$str1 = $fn_h{$key};
		$af = $_;
		last;
	    }
	}
    }##
    elsif($dalis_id == 2) {
    # veiksmažodžio paieška ~ direktorijoje esančiuose žodynuose #
	if(find_in($fh_h{3}, $word)) {
	    $str1 = $fn_h{3};
	    $af = $_;
	    last;
	}
    }##
    elsif($dalis_id == 3) {
    # būdvardžio paieška ~ direktorijoje esančiuose žodynuose #
	if(find_in($fh_h{4}, $word)) {
	    $str1 = $fn_h{4};
	    $af = $_;
	    last;
	}
    }##
    elsif($dalis_id == 4) {
    # nekaitomo žodžio paieška ~ direktorijoje esančiuose žodynuose #
	foreach $key (5,6) {
	    if(find_in($fh_h{$key}, $word)) {
		$str1 = $fn_h{$key};
		last;
	    }
	}
    }##
    elsif($dalis_id == 5) {
    # jargon paieška ~ direktorijoje esančiuose žodynuose #
	if(find_in($fh_h{7}, $word)) {
	    $str1 = $fn_h{7};
	    last;
	}
    }##
    if ($found_u) { print "\n$R"."Dėmesio$d".", žodis $B$word$Y\/$af$d yra žodyne \'$str1\'.";  }
}  

sub taip_ne($$) {
    my $msg = shift;
    my $def_ans = shift;
    my $kart = 0;
    do {
	if ($kart > 3) { 
	    print "\n$d"."Įveskite ($G"."t$d,$G"."n$d arba $G"."q$d): $B"; 
	}
	else { print "$msg ($G"."t$d\/$G"."n$d\) [$B"."$def_ans$d\]: $B"; }
    	$_ = <STDIN>;
	print "$d";
	if (!defined || /q/i) {  return; }
	chomp($_);
	$_ = $def_ans if $_ eq '';
	$kart++;
    } until /^[tnq]$/i;
    return (/t/i) ? 1 : 2;
}

sub ivesti_zodi($;$) {
    my $msg = shift;
    my $def_word = shift ;
    my $kart = 0;
    do {
	if($kart >= 3) { print "\nĮveskite teisingą žodį ($G"."q$d sugrįžti į pradžią): $B"; } 
	else { 
	    if( defined($def_word) && $def_word ne '' ) { print "$msg [$B$def_word$d\]: $B"; }
	    else { print "$msg: $B"; }
	} 
	$_ = <STDIN>;
	print "$d";
	if (!defined || /q/i) {  return; }
	chomp ($_);
	if( $_ eq '' && defined($def_word) ) { $_ = $def_word; }
    } until (legal ($_) );
    return $_;
}

sub sub_exit {
    print "$d";
    exit;
}

sub irasyti_izodyna ($$) {
    my $id = shift;
    my $word = shift;
    my $idx;
    
    if ($id == 1) { $idx = 1; }
    elsif ($id == 2) { $idx = 3; }
    elsif ($id == 3) { $idx = 4; }
    elsif ($id == 4) { $idx = 5; }  
    elsif ($id == 5) { $idx = 7; }  
   
    write_to($fh_h{$idx}, $word);

}

sub write_to($$)
{
    my $FH = shift;
    my $word = shift;

    seek($FH, 0, 2) or die "$R"."Dėmesio$d\, negaliu pereiti į failo galą.\n";
    print $FH "$word\n" or die "$R"."Dėmesio$d\, negaliu įrašyti į failo galą.\n";
    print "Įrašyta\n";
}

sub find_in($$)
{
    my $FH = shift;
    my $word = shift;
    $found_u = 0;
    
    if (tell($FH)) { seek($FH, 0, 0) or die "$R"."Dėmesio$d\, negaliu pereiti į failo pradžią.\n"; }
    while ( <$FH> ) {
	if (/^$word(\/(.+))?$/i) {
	    $found_u = 1;
	    $_ = $2;
	    last;
	}
    }
    if ($found_u) {  return ($_) ? $_ : 1; }
}

sub append_flags($$$;$) {
    my $msg = shift;
    my $def = shift;
    my $f_true = shift;
    my $f_false = shift;
    my $ats = taip_ne($msg, $def);
    if(!$ats) { return; }
    elsif($ats == 1) { $flags .= $f_true; }
    elsif($ats == 2 && defined($f_false)) { $flags .= $f_false; }
    return $ats;
}

sub veiks_tikrinimas (\$\$\$) {
    my $bend = shift;
    my $es = shift;
    my $but = shift;
    my ($msg, $ats);
    
    # Patikrinimas ar teisingai rašmos nosinės balsės veiksmažodžių šaknyse prieš raidę 's'
    if ( $$bend =~ /^(.*)(.)([aeiyuū])(s.*)$/i || $es =~ /^(.*)(.)([aeiyuū])(s.*)$/i ) {
	my ($_1, $_2, $_3, $_4) = ($1, $2, $3, $4);
	my $itart; # įtartina bendratis?(1), esamasis laikas?(0), abu?(2) 
	($$bend eq "$1$2$3$4") ? ($itart = 1) : ($itart = 0);
	if ($itart) { ($$es =~/$1$2$3s.*/i) ? ($itart = 2)  : ($itart = 1); }
	if ( $$es =~ /$1$2[aeiu]n.*/i || $$but =~ /$1$2[aeiu]n.*/i || $$bend =~ /$1$2[aeiu]n.*/i ) {
	    print "\n$R"."Dėmesio$d\, nosinės balsės $B"."ą$d\,$B"."ę$d\,$B"."į$d\,$B"."ų$d rašomos veiksmažodžių šaknyse prieš \'$d"."s$d\',\nkai pagrindiniuose kamienuose šios balsės kaitaliojasi su $G"."an$d\,$G"."en$d\,$G"."in$d\,$G"."un$d.\n$Y"."Pvz:$d\n\tgr$B\į$d\(s)ti : gr$G"."in$d"."džia, gr$G"."in$d"."dė; br$B"."ę$d\(s)ti, br$B"."ę$d\(s)ta : br$G"."en$d"."do...\n"; 
	    $_ = $_3;
	    if( /a/i ) { $_ = 'ą'; }
	    elsif( /e/i ) { $_ = 'ę'; }
	    elsif( /[uū]/i ) { $_ = 'ų'; }
	    elsif( /[iy]/i ) { $_ = 'į'; }
	    my ($str1, $str2, $es_tb, $bend_tb); # $es_tb, $bend_tb - (t)urėtų (b)ūti
	    print "-------------------------------------------------------------------------------";
	    if ($itart == 2) {
		my $tmp = $$es;
		$tmp =~ s/$_1$_2$_3(.*)/$_1$_2$G$_3$d$1/i;
	        $str1 = "\'$_1$_2$G$_3$d$_4\', \'$tmp\'";
		$tmp = $$es;
		$tmp =~ s/$_1$_2$_3(.*)/$_1$_2$_$1/i;
	        $es_tb = $tmp;
		$bend_tb = "$_1$_2$_$_4";
	        $tmp =~ s/^$_1$_2$_(.*)/$_1$_2$G$_$d$1/i ;
	        $str2 = "\'$_1$_2$G$_$d$_4\', \'$tmp\'";
            }
	    else { 
		$str1 = "$_1$_2$G$_3$d$_4"; 
		$str2 = "$_1$_2$G$_$d$_4"; 
		($itart == 0) ? ($es_tb = "$_1$_2$_$_4") : ($bend_tb = "$_1$_2$_$_4");  
	    }
	    do {
		print "\n$B"."Jūs įvedėte$d $str1 nors taisyklė byloja, kad:\n$R"."Turėtų būti$d $str2.\n";
		$msg = "Ar sutinkate su taisyke?";
		if(! ($ats = taip_ne($msg, 't')) ) {  return; }
		elsif($ats == 2) {
		    $msg = "Neregėtas užsispyrimas.. :). Belieka paklausti ar esate įsitikinę, kad žodžius\nįvedėte teisingai?\n$$bend, $$es, $$but?";
		    if(! ($ats = taip_ne($msg, "n")) ) {  return; }
		
		}
		else { 
		    if($es_tb) { $$es = $es_tb; } 
		    if ($bend_tb) { $$bend = $bend_tb; }
		    print "\n$$bend, $$es, $$but\n";
		}
	    } while ($ats == 2);
	}
    }
    return 1;
}

sub pagalba() {
    system('clear');
    print "Programos veikimo $G"."principas$d\:\n";
    print "Žodžių kaupimas yra išskirtas į 5 pagrindinius skyrius, tai yra:\n";
    print "    -$B Daiktavardis$d\n";
    print "    -$B Veiksmažodis$d\n";
    print "    -$B Būdvardis$d\n";
    print "    -$B Nekaitoma$d\n";
    print "    -$B Jargon$d\n";
    print "    Įvedus žodį bei pasirinkus skyrių, programa paprašys įvesti šakninę žodžio\n";
    print "formą(daiktavardžiams, būdvardžiams  - vardininko laipsnis, veiksmažodžiams tai\n";
    print "yra bendratis, esamasis bei būtasis kartinis laikai). Sąvoka \"šakninis žodis\"\n";
    print "reiškia, kad šis žodžis kartu su nustatytais afiksų parametrais(vėliavėlės) bus\n";
    print "išsaugotas žodyne.\n";
    print "    Toliau programa ieško jūsų įvesto šakninio žodž-io(ių) pagrindiniame bei \n";
    print "-(p|P) raktu nurodytoje arba namų direktorijoje(/~) esančiuose žodynuose.\n";
    print "    Jei žodis iš tikrųjų nežinomas, programa kaip įmanoma draugiškiau paprašys\n";
    print "suteikti jai paildomą informaciją(žodžio linksniai, laikai, priešdėliai,\n";
    print "galūnės, kita) kuri reikalinga teisingiems žodžio afiksams nustatyti. Po visų\n"; 
    print "šių veiksmų, jums sutikus, žodis bus įrašytas į atitinkamą žodyną.\n\n";
    print "    -$B Ctrl+D$d - bet kada grįžta į programos pradžią. Esant programos pradžioje\n";
    print "ši kombinacija nutraukia jos vykdymą.\n";
    print "    -$B Ctrl+C$d - bet kada nutraukia programos vykdymą.\n";
}

sub usage()
{
print "$versija\n";
print "\nProgramos argumentai:\n\n";
print "-b, -B\tNenaudoti spalvų(įprastas, bespalvis tekstas)\n";
print "-f, -F\tFailas iš kurio bus skaitomi ir nagrinėjami žodžiai.\n\tNutylėjus(nenurodžius -f ar -F) bus skaitomi ir nagrinėjami vartotojo\n\tįvedami žodžiai\n";
print "-h, -H\tPagalba(šis programos argumentų sąrašas)\n";
print "-p, -P\tDirektorija, kurioje saugomi žodyno failai.\n\tNutylėjus(nenurodžius -p ar -P) tai yra vartotojo namų direktorija /~\n";

}
