진화를 꿈꾸다..

package filter;

import java.util.StringTokenizer;

public class Morphemer {
 private String[] bpstWord ={"だから", "から", "まで", "あまり", "まり", "ただし", "やらだけ",
   "らかし", "ずに", "かり", "たぶん", "ながら", "たくさん", "（", "）", "(", ")", "いなあ", "うえで", "それで",
   "しまった", "しまう", "よう", "こうした", "たち", "そう", "あらかた", "でしょうか", "でも", "らどう",
   "すごく", "でき,", "ぶり", "ください", "必ず", " ", ".", "。", "、", "，", "？", "“", "”",
   "「", "」", "【", "】", "は", "を", "の", "ため", "さん", "ころ", "しかし", "と", "も", "よく", "ここ"};
 private String[] verbWord = {"ます", "あります", "ありません", "がった", "する",
   "てす", "ている", "ない", "ないてす", "う", "つ", "る", "ぬ", "む", "ぶ", "く", "ぐ",
   "す", "ましす", "いた", "った", "した", "んた", "いたし", "ったし", "したし", "ただし",
   "んたし", "いて", "って", "して", "んで", "て", "がいる", "がある", "させる", "せる"};
 private String[] pastVerb = {"ましす", "がった", "いた", "った", "した", "んだ", "れた", "めた", "又"};
 private String[] iadverb = {"いて", "って", "して", "んで"};
 private String[] adverbWord = {"くて", "に", "く", "な", "ただ"};
 private String[] adjWord = {"い", "な"};
 private String[] subWord = {"えば", "けば", "げば", "せば", "ぜば", "てば",
   "でば", "ねば", "へば", "べば", "めば", "れば"};
// private String[] lastfChar = {"か", "そ", "や", "ら", "く", "り", "だ",
//   "ん", "に", "っ", "ア", "こ", "き", "せ", "て", "あ", "ち", "つ",
//   "る", "む", "す", "か", "う", "え", "ど", "で", "さある", "う", "が"}; こ
 private String[] lastfChar = {"あ", "ぁ", "か", "が", "さ", "ざ", "た", "だ", "な", "は", "ば",
   "ぱ", "ま", "や", "ゃ", "ら", "わ", "ゎ", "ん", "い", "ぃ", "き", "ぎ", "し", "じ", "ち",
   "ぢ", "に", "ひ", "び", "ぴ", "み", "り", "う", "ぅ", "く", "ぐ", "す", "ず", "つ", "づ",
   "っ", "ぬ", "ふ", "ぶ", "ぷ", "む", "ゆ", "ゅ", "る", "え", "ぇ", "け", "げ", "せ", "ぜ",
   "て", "で", "ね", "へ", "べ", "ぺ", "め", "れ", "お", "ぉ", "こ", "ご", "そ", "ぞ", "と",
   "ど", "の", "ほ", "ぼ", "ぽ", "も", "よ", "ょ", "ろ", "を", "ア", "ァ", "カ", "ガ", "サ",
   "ザ", "タ", "ダ", "ハ", "バ", "パ", "マ", "ヤ", "ャ", "ラ", "ワ", "ヮ", "ン", "イ", "ィ",
   "キ", "ギ", "シ", "ジ", "チ", "ヂ", "ニ", "ヒ", "ビ", "ピ", "ミ", "リ", "ウ", "ゥ", "ク",
   "グ", "ス", "ズ", "ツ", "ヅ", "ッ", "ヌ", "フ", "ブ", "プ", "ム", "ユ", "ュ", "ル", "エ",
   "ェ", "ケ", "ゲ", "セ", "ゼ", "テ", "デ", "ネ", "ヘ", "ベ", "ペ", "レ", "オ", "ォ", "コ",
   "ゴ", "ソ", "ゾ", "ト", "ド", "ホ", "ボ", "ポ", "モ", "ヨ", "ョ", "ロ", "ヲ", "―",
   "１", "２", "３", "４", "５", "６", "７", "８", "９", "０"};
 
 public Morphemer(String str){
  splitMorpheme(str);
 }
 
 public boolean isNoun(String str){
  boolean isN = false;
//  if(str.contains("ん")){System.out.println(str);}
  if(isSubjunctive(str)){
   isN = false;
  }else if(isAdj(str)){
   isN = false;
  }else if(isVerb(str)){
   isN = false;
  }else{isN = true;}
  
  return isN;
 }
 
 public boolean isSubjunctive(String str){
  boolean isSub = false;
  for(int i=0; i<subWord.length; i++){
   if(str.contains(subWord[i])){
    isSub = true;
   }
  }
  return isSub;
 }
 public boolean isAdj(String str){
  boolean isAdj = false;
  for(int i=0; i<adjWord.length; i++){
   if(str.contains(adjWord[i])){
    isAdj = true;
   }
  }
  return isAdj;
 }
 
 public boolean isAdverb(String str){
  boolean isAdverb = false;
  
  for(int i=0; i<adverbWord.length; i++){
   if(str.contains(adverbWord[i])){
    isAdverb = true;
   }
  }
 return isAdverb;
 }
 
 public boolean isVerb(String str){
  boolean isV = false;
//  if(str.contains("ん")){System.out.println(str);}
  if(str.length()>1){
   for(int i=0; i<verbWord.length; i++){    
    if(str.contains(verbWord[i])
      &&(!str.contains("さ"))
      &&(!str.contains("み"))){
//     System.out.println(str);
     isV = true;
     break;
    }
   }
  }
  return isV;
 } 
 
 // 해당 keyword가 포함된 문장을 리턴 한다.
 public boolean containKeyWord(String str, String keyWord){
  boolean isContain = false;
  if(str.contains(keyWord)){
   isContain = true;
  }
  return isContain;
 }
 
 public String[] split(String target, String token){
  StringTokenizer st = new StringTokenizer(target, token);
  String[] ret = new String[st.countTokens()];
  String split = null;
  
  int i = 0;  
  while(st.hasMoreElements()){
   split = st.nextToken();
   if(split!=null && !split.equals("")){
    if(token=="<"){    
     ret[i] = token + split;    
     i++;
    }else if(token==">"){
     if(split.contains("<")){
      ret[i] = split + token;     
      i++;
     }else{
      ret[i] = split;     
      i++;
     }
    }else {
     ret[i] = split;    
     i++;
    } 
   }
  }
  
  return ret;
 }
//  tag를 걸러낸  string 중 keyword를 포함한 문장을 리턴한다.
 public String strByKeyword(String str, String key){  
  String splitStr[] = null;  
  String ret = null;  
    
  splitStr = split(str, "\n");  
    
  for(int i=0; i<splitStr.length; i++) {
   // 해당 키워드를 포함한 문장을 가지고 온다.
   if(containKeyWord(splitStr[i], key)){ret = splitStr[i];}        
  }
  if(ret!=null){  
   ret.replace(" ", "").replace("\t", "");  
  }
  return ret;
 } 
  
 public String parserVerb(String str){
  String[] split = split(str, "|");
  String ret = "|";
  
  for(int z=0; z<split.length; z++){
   if(split[z]!=null){
    for(int i=0; i<verbWord.length; i++){
     // 명사일 수도 있으니까..........
     if(split[z].contains(verbWord[i])){        
      for(int j=0; j<pastVerb.length; j++){
       if(split[z].contains("ついて")){
        split[z] = split[z].replace("ついて", "ついて" + "|");
       }else{
        split[z] = split[z].replace(pastVerb[j], pastVerb[j] + "|");       
       }
      }
      if(!split[z].contains("さ")){     
       if(split[z].contains("う")){
        split[z] = split[z].replace("う", "う" + "|");     
       }else if(split[z].contains("す")){
        split[z] = split[z].replace("す", "す" + "|");     
       }
      }
  //    System.out.println(str);
     }else if(verbWord[i].equals("がいる")){
      split[z] = split[z].replace("がいる", "|"+ "が" + "|" + "いる" + "|");
     }else if(verbWord[i].equals("がある")){
      split[z] = split[z].replace("がある", "|"+ "が" + "|" + "ある" + "|");
     }else if(split[z].contains("が")&&!split[z].contains("がった")){
      split[z] = split[z].replace("が", "|"+ "が" + "|");
     }
    }
   }
   ret+=split[z] + "|";
  }
//  System.out.println(ret);
    
  return ret;
 }  
 
 public void splitMorpheme(String str){
  String[] sentence = split(str, "\n");
  String[] paragraph = null;
  
  for(int z=0; z<sentence.length; z++){
   sentence[z] = sentence[z].replace("こと", "事" + "|");
   // 먼저 자르고... {"、", "「", "」", "は", "を", "の", "と"}
   for(int i=0; i<bpstWord.length; i++){
    if(sentence[z].contains(bpstWord[i])){
     sentence[z] = sentence[z].replace(bpstWord[i], "|");
    }
   }
   // 예외 처리..
   if(sentence[z].contains("る")&&(sentence[z].indexOf("る")>0)){     
    sentence[z] = sentence[z].replace("る", "る" + "|");
   }
   if(sentence[z].contains("がった")){
    sentence[z] = sentence[z].replace("がった", "がった" + "|");
   }else if(sentence[z].contains("が")){   
    sentence[z] = sentence[z].replace("が", "|");
   }
   if(sentence[z].contains("んで")){
    sentence[z] = sentence[z].replace("んで", "んで" + "|");
   }
   if(sentence[z].contains("で")){
    sentence[z] = sentence[z].replace("で", "で" + "|");
   }
   if(sentence[z].contains("て")&&(sentence[z].indexOf("て")>0)){     
    for(int k=0; k<iadverb.length; k++){
     if(sentence[z].contains("ていく")){
      sentence[z] = sentence[z].replace("ていく", "て"+ "|" + "いく" + "|");     
     }else if(sentence[z].contains("ついて")){
      sentence[z] = sentence[z].replace("ついて", "ついて" + "|");
     }else if(sentence[z].contains("ている")){
      sentence[z] = sentence[z].replace("ている", "ている" + "|");
     }else {
      sentence[z] = sentence[z].replace(iadverb[k], iadverb[k] + "|");
     }
    }
   }
   if(sentence[z].contains("ば")&&(sentence[z].indexOf("ば")>0)){  
    sentence[z] = sentence[z].replace("ば", "ば" + "|");
   }  
   if(sentence[z].contains("に")&&(sentence[z].indexOf("に")>0)){
    sentence[z] = sentence[z].replace("に", "に" + "|");
   }
   if(sentence[z].contains("く")
     &&(sentence[z].indexOf("く")>0)
     &&!(sentence[z].contains("に"))){
    sentence[z] = sentence[z].replace("く", "く" + "|");
   }  
   //  다음 자를꺼.. {"い", "な"}  
   if(sentence[z].contains("い")&&(sentence[z].indexOf("い")>0)){
    if(sentence[z].contains("ついて")){
     sentence[z] = sentence[z].replace("ついて", "ついて" + "|");
    }else if(sentence[z].contains("いく")){
     sentence[z] = sentence[z].replace("いく", "いく" + "|");     
    }else if(sentence[z].contains("いて")){
     sentence[z] = sentence[z].replace("いて", "いて" + "|");
    }else if(sentence[z].contains("ている")){
     sentence[z] = sentence[z].replace("ている", "ている" + "|");
    }else if((sentence[z].contains("ご") ||sentence[z].contains("さ"))){
     sentence[z] = sentence[z].replace("い", "|" + "い");
    }else{
     sentence[z] = sentence[z].replace("い", "い" + "|");
    }
   }
   if(sentence[z].contains("な")
     &&(sentence[z].indexOf("な")>0)
     &&(!sentence[z].contains("ない"))
     &&(!sentence[z].contains("なか"))){
    sentence[z] = sentence[z].replace("な", "な" + "|");   
   }
   
   paragraph = split(sentence[z], "|");
   for(int j=0; j<paragraph.length; j++){
    paragraph[j] = paragraph[j].replace(" ", "").replace("\t", "").replace("\n", "");
    String[] phrase = split(paragraph[j], "|");
    for(int k=0; k<phrase.length; k++){
     String word = parserVerb(phrase[k]);
     analysisMorpheme(word);         
    }
   }
   
  }
 }
 
 public void analysisMorpheme(String str){ 
  String[] word = split(str, "|");
  for(int i=0; i<word.length; i++){
   word[i] = word[i].replace(" ", "").replace("\t", "").replace("\n", "");   
   for(int j=0; j<lastfChar.length; j++){
    if(word[i].indexOf(lastfChar[j])==0){
//     System.out.println(word[i].indexOf(lastfChar[j]) + " : "+ word[i]);
     word[i] = null;  
     break;
    }
   }
   if(word[i]!=null){
    defineFormat(word[i]);    
   }
  }
 }
 
 public void defineFormat(String str){
  String type = null;
  
  if(str!=null && !str.equals(" ")){
   if(isAdj(str)){
    if(str.contains("ている")){
     type = "いるv";
    }else if(str.contains("いる") ){
     type = "いるv";
    }else if(str.contains("い")
      &&str.length()>1
      &&(str.indexOf("い")+1==str.length())){
     type = "いadj";
    }else if(str.contains("な")
      &&str.length()>1
      &&(str.indexOf("な")+1==str.length())){
     type = "なadj";
    }
   }else if(isVerb(str)&&!isAdj(str)){    
    type = str.substring(str.length()-1)+"v";
    if(str.contains("ついて")){
     type = "てv";
//     System.out.println("て.Verb : " + str);
    }else if(str.contains("ている")){
     type = "ているv";
//     System.out.println("ている.Verb : " + str);
    }else if(str.contains("いる")){
     type = "いるv";
//     System.out.println("ている.Verb : " + str);
    }else if(str.contains("てある")){
     type = "てあるv";
//     System.out.println("てある.Verb : " + str);
    }else if(str.contains("て")){  
     type = "てv";
//     System.out.println("て.Verb : " + str);
    }else if(str.contains("た")||str.contains("だ")){     
     for(int i=0; i<pastVerb.length; i++){
      if(str.contains(pastVerb[i])){
       type = "たv";
//       System.out.println("past.た.Verb : " + str);
      }
     }
    }else if(str.contains("いく")){
     type = "くv";
//     System.out.println("Verb : " + str);     
    }else if(str.contains("する")){
     type = "するv";
//     System.out.println("Verb : " + str);     
    }else if(str.contains("く") && !str.equals("く")){     
     if(isAdverb(str)){
      type = "adv";
//      System.out.println("Adj : " + str);
     }
    }    
   }else if(isNoun(str)&&!isAdj(str)&&!isVerb(str)){
    type = "n";
    if(isAdverb(str) && !str.equals("に")){
     if(str.contains("に")){
      type = "にadv";
//      System.out.println("に.Adverb : " + str);
     }else{
      type = "adv";
//      System.out.println("Adverb : " + str);
     }
    }else if(str.contains("で")){    
     str = str.replace("で", "");
//     System.out.println("に.Adverb : " + str);
    }else if(str.contains("だ")){ 
     if(str.contains("んだ")){
      type = "たadj";
     }else{str = str.replace("だ", "");}
//     System.out.println("に.Adverb : " + str);
    }    
   }  
  }
  if(str!=null){
   for(int i=0; i<iadverb.length; i++){
    if(str.equals(iadverb[i]) || str==iadverb[i]){
     type = null;
     str = str.replace(iadverb[i], "");
    }
   }   
  }
  str = str.replace(" ", "").replace("\t", "").replace("\n", "");
  if((type!=null)&&(!str.equals(""))){   
   // 10글자 미만만...
   if(str.length()<10){
    System.out.println(type + "  : " + str);
   }
  }
 }
 
}