/*
                                Denise-MYTH Artificial Intelligence.

                                  Copyright (C) 2000 Szymon Jessa

                                         WERSJA ANGIELSKA:

This  program  is free software; you can redistribute it and/or modify it under the terms of the GNU
General  Public  License  as  published  by  the  Free  Software Foundation; either version 2 of the
License, or (at your option) any later version.

This  program  is  distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
even  the  implied  warranty  of  MERCHANTABILITY  or  FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.

You  should  have received a copy of the GNU General Public License along with this program; if not,
write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

                                           WERSJA POLSKA:

Niniejszy   program   jest  oprogramowaniem  wolnodostëpnym;  moûesz  go  rozprowadzaê  dalej  i/lub
modyfikowaê na warunkach Powszechnej Licencji Publicznej GNU, wydanej przez Fundacjë Wolnodostëpnego
Oprogramowania - wedîug wersji 2-giej tej Licencji lub którejô z póúniejszych wersji.

Niniejszy   program  rozpowszechniany  jest  z  nadziejâ,  iû  bëdzie  on  uûyteczny  -  jednak  BEZ
JAKIEJKOLWIEK  GWARANCJI,  nawet  domyôlnej  gwarancji  PRZYDATNOÔCI  HANDLOWEJ albo PRZYDATNOÔCI DO
OKREÔLONYCH ZASTOSOWAÏ. W celu uzyskania bliûszych informacji - Powszechna Licencja Publiczna GNU.

Z  pewnoôciâ  wraz  z niniejszym programem otrzymaîeô teû egzemplarz Powszechnej Licencji Publicznej
GNU; jeôli nie - napisz do Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

                                              KONTAKT:

snail: Szymon Jessa, ul. Warszawska 20/6, 89-600 Chojnice,
email: smoczek@ue.eti.pg.gda.pl (ew. noco@box43.gnet.pl)
phone: (052) 39-707-88

****************************************************************************************************
*/
// *******************************************************
// * * * D E N A T U R A L I Z A C J A   Z D A N I A * * *
// *******************************************************

char FROM analiza_naturalna(struct sentence_struct *pointer)
{
	/*
	funkcja filtruje zdanie ze zbëdnych zwrotów, wyraûeï, co umoûliwia
	posîugiwanie sië jëzykiem prawie zupeînie naturalnym, z jednoczesnym
	zrozumieniem zdania przez Denise,
	*/

	char nr1;

	if (sentence_filter==KOD_FALSE) return RESULT_OK;

	// kasowanie lub zamienianie elementów zbëdnych (przypuszczalnie) ze zdania
   filtruj_rozpoczecie(pointer);
   filtruj_calosc(pointer);
   tlumacz_zwroty(pointer);

   // wzbogacenie zdania o jakieô wyrazy
   wzbogacanie_zdania(pointer);

	// jeôli nie jest wîâczone wyôwietlanie fleksji, to wychodzimy
	if (view.fleksja==KOD_FALSE) return RESULT_OK;

	// wypisanie zdania w nowej formie (takiej, jakâ widzi Denise)
	con_put("forma uproszczona: ");
	for (nr1=0;nr1<pointer->ile_wyrazow;nr1++)
   {
      con_put(pointer->wyraz[nr1]);
      if (nr1<pointer->ile_wyrazow-1) con_put(" ");
	}
   con_put("\n");

	return RESULT_OK;
}

void FROM kasuj_wyraz(struct sentence_struct *pointer,char wyraz)
{
   char nr1;

   if (wyraz<pointer->ile_wyrazow-1)
   {
      for (nr1=wyraz+1;nr1<pointer->ile_wyrazow;nr1++)
		{
			strcpy(pointer->wyraz[nr1-1],pointer->wyraz[nr1]);
		}
	}

	if (pointer->ile_wyrazow>0) pointer->ile_wyrazow--;
}

void FROM wstaw_wyraz(struct sentence_struct *pointer,char pozycja,char *wyraz)
{
   char nr1;

   if (pozycja<=pointer->ile_wyrazow)
   {
      for (nr1=pointer->ile_wyrazow+1;nr1>pozycja;nr1--)
		{
			strcpy(pointer->wyraz[nr1],pointer->wyraz[nr1-1]);
		}
	}

   strcpy(pointer->wyraz[pozycja],wyraz);

	pointer->ile_wyrazow++;
}

char FROM filtruj_rozpoczecie(struct sentence_struct *pointer)
{
   /*
   funkcja kasuje pierwsze wyrazy, które zostaîy uznane za zbëdne
   w analizie logicznej (dla Elizy sâ one ciâgle widoczne)
   */

   char nr1,nr2,*end,space[2],temp_zwrot[MAX_LINE_LENGHT];
   char wyraz[MAX_ILE_WYRAZOW][MAX_LINE_LENGHT],ile_wyrazow;
   // zwroty sâ po: 5, 10 w linii (oraz resztki)
   char *zwroty[117]={
   "chcesz powiedzieê ûe","wynika stâd ûe","to znaczy ûe","sprowadza sië do tego ûe","mówisz ûe",
   "wydaje mi sië ûe","mam wraûenie ûe","coô mi mówi ûe","mam przeczucie ûe","nie wierzë ûe",
   "zaîoûë sië","powiem ci","mówië ci","zdradzë ci","wyjaôniam ci",
   "pewnie ûe","myôlë ûe","myôlisz ûe","przypuszczam ûe","przypuszczasz ûe",
   "przypuszcza ûe","prawdopowobne ûe","chyba ûe","uwaûam ûe","uwaûasz ûe",
   "uwaûa ûe","zakîad ûe","zakîadam ûe","zakîadasz ûe","zakîada ûe",
   "twierdzë ûe","twierdzisz ûe","twierdzi ûe","wnioskujë ûe","wnioskujesz ûe",
   "wnioskuje ûe","uznajë ûe","uznajesz ûe","uznaje ûe","sâdzë ûe",
   "sâdzisz ûe","sâdzi ûe","tylko ûe","moûliwe ûe","moim zdaniem",
   "twoim zdaniem","jego zdaniem","jej zdaniem","naszym zdaniem","ich zdaniem",
   "dzieï dobry","pewne ûe","powiedz mi","powiedz czy","dobrze ûe",
   "jak myôlisz","jak sâdzisz","jak uwaûasz","jak przypuszczasz","to prawda",
   "czeôê denise","witaj denise","hej denise","dzieï dobry denise","bo",
   "poniewaû","dlatego ûe","jestem zdania ûe","jesteô zdania ûe","jest zdania ûe",
   "powiesz mi","powiedz mi",
   "a","wiëc","przecieû","niestety","czeôê","witaj","hej","hi",
   "ach","ah","oh","hm","hmm","hmmm","ups","uff","egh","eh",
   "brr","spoko","aleû","ûe","cóû","ale","lecz","ów","ten",
   "ûe","juû","niech","dlaczego","aha","teraz","he","ha",
   "cha","che","hey","ho","uf","uff","teû","równieû","takûe","oto"};

   sprintf(space," ");

	// partykuîa "CZY" na poczâtku zdania ôwiadczy jedynie o pytaniu
	if (strcmp(pointer->wyraz[0],"czy")==0)
   {
      kasuj_wyraz(pointer,0);
      pointer->oznajm_pyt=ZDANIE_PYTAJACE;
   }

   for (nr1=0;nr1<117 && pointer->ile_wyrazow>0;nr1++)
   {
      sprintf(temp_zwrot,"%s",zwroty[nr1]);

      // pobranie wyrazów wystëpujâcych w wyraûeniu
      for (ile_wyrazow=0;;ile_wyrazow++)
      {
         if ((end=strpbrk(temp_zwrot,space))==NULL)
         {
            sprintf(wyraz[ile_wyrazow++],"%s",temp_zwrot);
            sprintf(temp_zwrot,"");
            break;
         }
         else
         {
            sprintf(wyraz[ile_wyrazow],"%.*s",strlen(temp_zwrot)-strlen(end),temp_zwrot);
            memmove(temp_zwrot,end+1,strlen(end));
         }
      }

      // jeôli liczba wyrazów > niû w zdaniu to pomijamy ten zwrot
      if (ile_wyrazow>pointer->ile_wyrazow) continue;

      // sprawdzamy wystëpowanie zwrotu w zdaniu
      for (nr2=0;nr2<ile_wyrazow;nr2++)
      {
         if (strcmp(pointer->wyraz[nr2],wyraz[nr2])!=0) goto NEXT_ZWROT;
      }

      // wycinamy wyrazy ze zdania (filtrujemy)
      for (nr2=0;nr2<ile_wyrazow;nr2++) kasuj_wyraz(pointer,0);

      // rekurencyjne wywoîanie gwarantuje lepszâ sprawnoôê funkcji
      filtruj_rozpoczecie(pointer);
      return RESULT_OK;

      NEXT_ZWROT: continue; // kubice kubice! i szalikowcy!
   }

   return RESULT_OK;
}

char FROM filtruj_calosc(struct sentence_struct *pointer)
{
   /*
   funkcja kasuje wyrazy, które zostaîy uznane za zbëdne
   w analizie logicznej (dla Elizy sâ one ciâgle widoczne)
   */

   char nr1,nr2,nr3,*end,space[2],temp_zwrot[MAX_LINE_LENGHT];
   char wyraz[MAX_ILE_WYRAZOW][MAX_LINE_LENGHT],ile_wyrazow;
   char *zwroty[56]={
   "a","wiëc","przecieû","niestety","czeôê","witaj","hej","hi",
   "ach","ah","oh","hm","hmm","ups","uff","egh","eh","uf","br",
   "brr","spoko","aleû","ûe","cóû","ale","lecz","ów","ten",
   "ja","ty","on","ona","ono","ûe","juû","niech","dlaczego","teraz","he","ha",
   "cha","che","jeszcze","równieû","takûe","gdyû","bo","acha","aha",
   "kaûdy","kaûda","kaûde","ûaden","ûadna","ûadne","zawsze"};

   sprintf(space," ");

   for (nr1=0;nr1<56 && pointer->ile_wyrazow>0;nr1++)
   {
      sprintf(temp_zwrot,"%s",zwroty[nr1]);

      // pobranie wyrazów wystëpujâcych w wyraûeniu
      for (ile_wyrazow=0;;ile_wyrazow++)
      {
         if ((end=strpbrk(temp_zwrot,space))==NULL)
         {
            sprintf(wyraz[ile_wyrazow++],"%s",temp_zwrot);
            sprintf(temp_zwrot,"");
            break;
         }
         else
         {
            sprintf(wyraz[ile_wyrazow],"%.*s",strlen(temp_zwrot)-strlen(end),temp_zwrot);
            memmove(temp_zwrot,end+1,strlen(end));
         }
      }

      // jeôli liczba wyrazów > niû w zdaniu to pomijamy ten zwrot
      if (ile_wyrazow>pointer->ile_wyrazow) continue;

      // sprawdzamy wystëpowanie zwrotu w zdaniu na kaûdej pozycji
      for (nr2=0;nr2<=pointer->ile_wyrazow-ile_wyrazow;nr2++)
      {
         // sprawdzamy, czy w tym miejscu jest ten zwrot
         for (nr3=0;nr3<ile_wyrazow;nr3++)
         {
            if (strcmp(pointer->wyraz[nr2+nr3],wyraz[nr3])!=0) goto NEXT_POZ;
         }
         goto FOUNDED; // jeôli znaleziono ten zwrot

         NEXT_POZ: continue; // ku-be continued
      }
      goto NEXT_ZWROT;

      FOUNDED: // jeôli znaleziono zwrot w zdaniu

      // wycinamy wyrazy ze zdania (filtrujemy)
      for (nr3=0;nr3<ile_wyrazow;nr3++) kasuj_wyraz(pointer,nr2);

      // rekurencyjne wywoîanie gwarantuje lepszâ sprawnoôê funkcji
      filtruj_calosc(pointer);
      return RESULT_OK;

      NEXT_ZWROT: continue; // kubice kubice! i szalikowcy!
   }

   return RESULT_OK;
}

char FROM tlumacz_zwroty(struct sentence_struct *pointer)
{
   /*
   funkcja zamienia róûne trudne logicznie zwroty na ich îatwiejsze
   odpowiedniki, np. "mam na imië XXX" -> "jestem XXX",
   */

   char nr1,nr2,nr3,*end,space[2],temp_zwrot[MAX_LINE_LENGHT];
   char wyraz[MAX_ILE_WYRAZOW][MAX_LINE_LENGHT],ile_wyrazow;
   char *zwroty[49][2]={
   {"wedîug ciebie",""},
   {"wedîug mnie",""},
   {"nazywam sië","jestem"},
   {"na imië mam","jestem"},
   {"na imië mi","jestem"},
   {"mam na imië","jestem"},
   {"mam na imie","jestem"},
   {"moje imië to","jestem"},
   {"moje imie to","jestem"},
   {"moje imië","jestem"},
   {"moje imie","jestem"},
   {"moja ksywa to","jestem"},
   {"mój pseudonim to","jestem"},
   {"tutaj mówi","jestem"},
   {"tu mówi","jestem"},
   {"noszë imië","jestem"},
   {"noszë imie","jestem"},
   {"tak jestem","jestem"},
   {"z tej strony","jestem"},
   {"nie nie jestem","nie jestem"},
   {"tak nie jestem","nie jestem"},
   {"to jest","to"},
   {"jest to","to"},
   {"to nie","nie to"},
   {"no","tak"},
   {"jo","tak"},
   {"racja","tak"},
   {"masz racjë","tak"},
   {"tak tak","tak"},
   {"tak sâdzë","tak"},
   {"tak myôlë","tak"},
   {"tak mi sië wydaje","tak"},
   {"tak uwaûam","tak"},
   {"tak jest","tak"},
   {"to prawda","tak"},
   {"to jest prawda","tak"},
   {"zgadza sië","tak"},
   {"oczywiôcie","tak"},
   {"pewnie","tak"},
   {"pewno","tak"},
   {"taki jestem","tak"},
   {"taka jestem","tak"},
   {"owszem","tak"},
   {"nie sâdzë","nie"},
   {"tak nie jest","nie"},
   {"to nie jest prawda","nie"},
   {"taki nie jestem","nie"},
   {"taka nie jestem","nie"},
   {"nie zgadza sië","nie"}};

   sprintf(space," ");

   for (nr1=0;nr1<49 && pointer->ile_wyrazow>0;nr1++)
   {
      sprintf(temp_zwrot,"%s",zwroty[nr1][0]);

      // pobranie wyrazów wystëpujâcych w wyraûeniu
      for (ile_wyrazow=0;;ile_wyrazow++)
      {
         if ((end=strpbrk(temp_zwrot,space))==NULL)
         {
            sprintf(wyraz[ile_wyrazow++],"%s",temp_zwrot);
            sprintf(temp_zwrot,"");
            break;
         }
         else
         {
            sprintf(wyraz[ile_wyrazow],"%.*s",strlen(temp_zwrot)-strlen(end),temp_zwrot);
            memmove(temp_zwrot,end+1,strlen(end));
         }
      }

      // jeôli liczba wyrazów > niû w zdaniu to pomijamy ten zwrot
      if (ile_wyrazow>pointer->ile_wyrazow) continue;

      // sprawdzamy wystëpowanie zwrotu w zdaniu na kaûdej pozycji
      for (nr2=0;nr2<=pointer->ile_wyrazow-ile_wyrazow;nr2++)
      {
         // sprawdzamy, czy w tym miejscu jest ten zwrot
         for (nr3=0;nr3<ile_wyrazow;nr3++)
         {
            if (strcmp(pointer->wyraz[nr2+nr3],wyraz[nr3])!=0) goto NEXT_POZ;
         }
         goto FOUNDED; // jeôli znaleziono ten zwrot

         NEXT_POZ: continue; // ku-be continued
      }
      goto NEXT_ZWROT;

      FOUNDED: // obsîuga w przypadku znalezienia zwrotu

      // wycinamy stare wyrazy ze zdania (filtrujemy)
      for (nr3=nr2;nr3<nr2+ile_wyrazow;nr3++) kasuj_wyraz(pointer,nr2);

      sprintf(temp_zwrot,"%s",zwroty[nr1][1]);

      // pobieramy nowe wyrazy majâce zastâpiê stary zwrot
      for (ile_wyrazow=0;;ile_wyrazow++)
      {
         if ((end=strpbrk(temp_zwrot,space))==NULL)
         {
            sprintf(wyraz[ile_wyrazow++],"%s",temp_zwrot);
            sprintf(temp_zwrot,"");
            break;
         }
         else
         {
            sprintf(wyraz[ile_wyrazow],"%.*s",strlen(temp_zwrot)-strlen(end),temp_zwrot);
            memmove(temp_zwrot,end+1,strlen(end));
         }
      }

      // wpisanie nowych wyrazów w miejsca starych
      for (nr3=ile_wyrazow;nr3>0 && strlen(wyraz[nr3-1])>0;nr3--) wstaw_wyraz(pointer,nr2,wyraz[nr3-1]);

      // rekurencyjne wywoîanie gwarantuje lepszâ sprawnoôê funkcji
      tlumacz_zwroty(pointer);
      return RESULT_OK;

      NEXT_ZWROT: continue; // kubice kubice! i szalikowcy!
   }

   return RESULT_OK;
}

void FROM wzbogacanie_zdania(struct sentence_struct *pointer)
{
   /*
   1) rozpoznawanie imienia rozmówcy
   - jeôli rozmóca nie jest rozpoznany,
   - jeôli podano tylko jeden wyraz,
   - jeôli jest to wyraz "rzeczownik, osobowy, wîasny",
   - wstawiamy wyraz "jestem",
   */

   struct fleksja_struct *word;

   // 1) rozpoznawanie imienia rozmówcy
   // - jeôli rozmóca nie jest rozpoznany,
   if (rozmowca.fakt!=NULL) return;

   // - jeôli podano tylko jeden wyraz,
   if (pointer->ile_wyrazow!=1) return;

   // - jeôli jest to wyraz "rzeczownik, osobowy, wîasny",
   if ((word=fleksja_find(pointer->wyraz[0],"",NULL,FULL))==NULL) return;
   if (*ptr_czesc_mowy(word->klon_head->dane)!=RZECZOWNIK) return;
   if (*ptr_osobowosc(word->klon_head->dane)!=OSOBOWY) return;
   if (*ptr_pospolitosc(word->klon_head->dane)!=WLASNY) return;

   // - dodajemy na poczâtku wyraz "jestem"
   wstaw_wyraz(pointer,0,"jestem");
}

// ***********************************************************
// * * * N A T U R A L I Z A C J A   W Y P O W I E D Z I * * *
// ***********************************************************

void FROM naturalizacja(char *zdanie,char oznajm_pyt,char *result)
{
   /*
   funkcja dodaje elementy naturalizujâce wypowiedú, zwraca wynik w zmiennej result
   naturalizacja przebiega inaczej dla zdaï twierdzâcych i pytajâcych
   */

   if (sentence_filter==KOD_FALSE) return;

   
}