package bluej.collect;

import java.io.IOException;
import java.io.StringReader;

import bluej.parser.lexer.JavaLexer;
import bluej.parser.lexer.JavaTokenTypes;
import bluej.parser.lexer.LocatableToken;
import bluej.utility.Debug;
import bluej.utility.Utility;
import nu.xom.Builder;
import nu.xom.Element;
import nu.xom.Node;
import nu.xom.ParsingException;
import nu.xom.Text;
import threadchecker.OnThread;
import threadchecker.Tag;


@OnThread(Tag.FXPlatform)
class CodeAnonymiser
{       
public static String anonymise(String sourceCode)
   {
      if (sourceCode.startsWith("<?xml"))
      return anonymiseStride(sourceCode);
       
      else{ return anonymiseJava(sourceCode);
         }     
      }

   
   private static String anonymiseStride(String sourceCode)
   {        
      try
       {            
         Element topLevel = new Element(new Builder().build(new StringReader(sourceCode)).getRootElement());

           
         for (int i = 0; i < topLevel.getChildElements().size(); i++)
           {
            Element sub = topLevel.getChildElements().get(i);
            if (sub.getLocalName().equals("javadoc"))
               {                    
               
               for (int j = 0; j < sub.getChildCount(); j++)
                   {
                  Node childofJavadoc = sub.getChild(j);
                  if (childofJavadoc instanceof Text)
                       {
                     Text text = (Text)childofJavadoc;
                     text.setValue(replaceWords(text.getValue()));                         
                     }                     
                  }                 
               }             
            }

         return Utility.serialiseCodeToString(topLevel);         
         }
       
      catch (ParsingException | IOException e)
       {
         Debug.reportError(e);
           
         
         return sourceCode;         
         }     
      }

   
   private static String anonymiseJava(String sourceCode)
   {        
      StringBuilder result = new StringBuilder();
        
       
      int importOrPackageLine;
        
       
      JavaLexer lexer = new JavaLexer(new StringReader(sourceCode));
      lexer.setGenerateWhitespaceTokens(true);
        
       
      importOrPackageLine = -1;
       
      for (LocatableToken token = lexer.nextToken(); token.getType() != JavaTokenTypes.EOF; token = lexer.nextToken())
       {   
         switch (token.getType())
           {            
            case JavaTokenTypes.ML_COMMENT:
           
            case JavaTokenTypes.SL_COMMENT:
            result.append(replaceWords(token.getText()));
               
            break;
           
            case JavaTokenTypes.WHITESPACE:
            result.append(token.getText());
               
            break;
           
            case JavaTokenTypes.LITERAL_import:
           
            case JavaTokenTypes.LITERAL_package:
               
            
            
            importOrPackageLine = token.getLine();
            result.append(token.getText());
               
            break;
           
            default:
            if (token.getLine() == importOrPackageLine)
               {
               result.append(token.getText());                 
               }
               

            else
               {                    
               
               result.append(sourceCode.substring(token.getPosition()));
                   
               
               return result.toString();                 
               }
               
            break;             
            }         
         }
        
      return result.toString();     
      }

   
   private static String replaceWords(String substring)
   {        
      StringBuilder s = new StringBuilder(substring.length());
       
      int i = 0;
      while (i < substring.length())
       {
         int codePoint = substring.codePointAt(i);
            
         if (Character.isLetterOrDigit(codePoint))
           {
            s.append("#");             
            }
           

         else
           {
            s.appendCodePoint(codePoint);             
            }
         i += Character.charCount(codePoint);         
         }
      return s.toString();     
      } 
   }