package bluej.parser;

import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import bluej.pkgmgr.JavadocResolver;
import bluej.stride.generic.InteractionManager.Kind;
import threadchecker.OnThread;
import threadchecker.Tag;

public class ImportedTypeCompletion
extends AssistContent{    
   private final String type;
   
   private final String canonicalName;
   
   private final String packageName;
   
   private final List<String> enclosingClasses;
   
   private final int modifiers;
   
   private final List<String> superTypes;
   
   private final Kind typeKind;
   
   private final String moduleName;
   
   private boolean extractedJavadoc = false;
   
   private String javadoc = null; 
   private final JavadocResolver resolver;
    
   
   public ImportedTypeCompletion(Class<?> cls, JavadocResolver resolver)
   {        
      
      
      this.type = cls.getSimpleName();
      this.canonicalName = cls.getCanonicalName();
      this.packageName = cls.getPackage().getName();
      this.modifiers = cls.getModifiers();
      this.moduleName = cls.getModule() != null ? cls.getModule().getName() : null;

       
      this.enclosingClasses = new ArrayList<>();
       
      for (Class<?> i  = cls.getEnclosingClass(); i != null; i = i.getEnclosingClass())
      enclosingClasses.add(0, i.getSimpleName());

       
      this.superTypes = new ArrayList<>();
       
      for (Class<?> i : cls.getInterfaces())
      superTypes.add(i.getName());
       
      for (Class<?> c = cls.getSuperclass(); c != null; c = c.getSuperclass())
       {
         superTypes.add(c.getName());         
         }
       
      this.resolver = resolver;
      if (cls.isInterface())
       {            
         this.typeKind = Kind.INTERFACE;         
         }

      else if (cls.isEnum())
       {            
         this.typeKind = Kind.ENUM;         
         }

      else if (cls.isPrimitive())
       {            
         
         this.typeKind = Kind.PRIMITIVE;         
         }
       

      else
       {
         this.typeKind = ((cls.getModifiers() & Modifier.FINAL) != 0) ?  Kind.CLASS_FINAL : Kind.CLASS_NON_FINAL;         
         }
           
      }

   
   @Override
   @OnThread(Tag.Any)
   
   public String getName()
   {        
      return type;     
      }

   
   @Override
   
   public List getParams()
   {        
      return null;     
      }

   
   @Override
   
   public String getType()
   {        
      return null;     
      }

   
   @Override
   
   public String getDeclaringClass()
   {
      if (enclosingClasses.isEmpty())
           
      return null;
       
      else{ return enclosingClasses.stream().collect(Collectors.joining("."));
         }     
      }

   
   @Override
   
   public CompletionKind getKind()
   {        
      return CompletionKind.TYPE;     
      }

   
   @Override
   @OnThread(Tag.FXPlatform)
   
   public String getJavadoc()
   {
      if (!extractedJavadoc)
       {
         javadoc = resolver.getJavadoc(moduleName, canonicalName);         
         }
       
      return javadoc;     
      }
    
   
   @Override
   
   public Access getAccessPermission()
   {
      return fromModifiers(modifiers);     
      }

   
   @Override
   
   public String getPackage()
   {        
      return packageName;     
      }
    
   
   @Override
   
   public List getSuperTypes()
   {        
      return superTypes;     
      }

   
   @Override
   
   public Kind getTypeKind()
   {        
      return typeKind;     
      }        
   }