/**
    * copyright by Grandsoft Company Limited.  
    * 2011-12-31
    */
   package gboat2.base.dao;
   
   import gboat2.base.core.dao.IBaseDAO;
   import gboat2.base.dao.aspect.GboatSessionFactoryAspect;
   import gboat2.base.dao.util.GBoatDaoClassLoader;
  
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  
  import javax.persistence.Entity;
  
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.MapUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.hibernate.SessionFactory;
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleActivator;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.BundleEvent;
  import org.osgi.framework.BundleException;
  import org.osgi.framework.BundleListener;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.ApplicationContextAware;
  import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;
  
  /**
   * bundle model对象注册工具类
   * @author liuliang,lysming
   * 2011-12-31
   */
  public class Activator implements BundleActivator, BundleListener, ApplicationContextAware {
  
  	private static final Logger logger = LoggerFactory.getLogger(Activator.class);
  
  	private static final String MODEL_PACKAGE_HEADER = "DynamicImport-Model";
  
  	/** 需要注册 POJO 的 Bundle */
  	private static final List<Bundle> bundlesToRegistPo = new ArrayList<Bundle>();
  
  	/** 已经完成 POJO 注册的 Bundle， key 为 Bundle 的 symbolicName， value 为 Bundle 实例 */
  	private static Map<String, Bundle> bundlesCache = new HashMap<String, Bundle>();
  
  	private static Collection<AnnotationSessionFactoryBean> sessionFactoryBeans;
  	private GboatSessionFactoryAspect sessionFactoryAspect;
  
  	/** key 为 Bundle 的 symbolicName， value 为该 Bundle 中所有的 VO、 PO 类 */
  	private static Map<String, List<Class<?>>> annotatedClassesMap = new HashMap<String, List<Class<?>>>();
  	
  	/** 保存所有要注册到 SessionFacotry 的类 */
  	private static List<Class<?>> registClasses = new ArrayList<Class<?>>();
  
  	private static GBoatDaoClassLoader gboatLoader = null;
  	
  	private IBaseDAO baseDAO;
  
      @Override
      public void setApplicationContext(ApplicationContext applicationContext) {
          if (sessionFactoryBeans == null) {
              Map<String, AnnotationSessionFactoryBean> sessionFactoryBeanMap = applicationContext.getBeansOfType(AnnotationSessionFactoryBean.class);
              if(MapUtils.isEmpty(sessionFactoryBeanMap))
                  throw new NoSuchBeanDefinitionException(AnnotationSessionFactoryBean.class, "无法将 Bundle 中的 POJO 注册到 Hibernate SessionFactory。");
              sessionFactoryBeans = sessionFactoryBeanMap.values();
              
              Map<String, GboatSessionFactoryAspect> sessionFactoryAspectMap = applicationContext.getBeansOfType(GboatSessionFactoryAspect.class);
              if(MapUtils.isNotEmpty(sessionFactoryAspectMap)) {
                  if(sessionFactoryAspectMap.size() > 1)
                      throw new NoUniqueBeanDefinitionException(GboatSessionFactoryAspect.class, sessionFactoryAspectMap.keySet());
                  
                  sessionFactoryAspect = sessionFactoryAspectMap.values().iterator().next();
              }
  
              if (bundlesToRegistPo.size() > 0) {
                  logger.debug("call registerPOJO by setApplicationContext");
                  registerPOJO();
              }
          }
      }
  
  	@Override
  	public void start(BundleContext context) throws Exception {
 		//registe gboatLoader 
 		if (gboatLoader == null) {
 		    // ID=0 的 Bundle 为系统 Bundle
 			gboatLoader = GBoatDaoClassLoader.createBundleClassLoaderFor(context.getBundle(0), this.getClass().getClassLoader());
 			if (gboatLoader == null) {
 				System.err.println("Error while start dao bundle, init ClassLoader failed. System will exit.");
 				System.exit(0);
 			}
 		}
 
 		Bundle[] bundles = context.getBundles();
 		StringBuffer symbolicNames = new StringBuffer();
 		for (Bundle bundle : bundles) {
 			if (bundle.getState() == Bundle.ACTIVE) {
 				if (!StringUtils.isEmpty(bundle.getHeaders().get(MODEL_PACKAGE_HEADER))) {
 				    symbolicNames.append("\r\n    ").append(bundle.getSymbolicName());
 					bundlesToRegistPo.add(bundle);
 				}
 			}
 		}
         logger.info("the pojo bundles is already started:{}" , symbolicNames);
 
 		//注册PO对象
 		if (CollectionUtils.isNotEmpty(bundlesToRegistPo) && CollectionUtils.isNotEmpty(sessionFactoryBeans)) {
 			logger.debug("call registerPOJO by start");
 			registerPOJO();
 		}
 		
 		//registe listener 
 		logger.info("register bundle listener for monitor PO.");
 		context.addBundleListener(this);
 	}
 
 	@Override
 	public void bundleChanged(BundleEvent event) {
 		Bundle bundle = event.getBundle();
 		synchronized (bundlesToRegistPo) {
 			if ((event.getType() & BundleEvent.STARTED) != 0) { // 启动 Bundle 时
 				//start：添加PO对象到处理列表中
 				logger.info("STARTED => {}({})", bundle, bundle.getLastModified());
 				if (bundlesCache.containsKey(bundle.getSymbolicName())) {
                     // 检查缓存，如果bundle发生变更，unintall旧的bundle
 					Bundle oldBundle = bundlesCache.get(bundle.getSymbolicName());
 					logger.info("cached old version is : bundleId={}, state={}", oldBundle.getBundleId(), oldBundle.getState());
 					if (oldBundle.getBundleId() != bundle.getBundleId()) {
 						try {
 							oldBundle.uninstall();
 						} catch (BundleException e) {
 							logger.warn("error to uninstall old version bundle", e);
 						} catch (IllegalStateException e) {
 							logger.warn(e.getMessage());
 						}
 					}
 					bundlesCache.remove(bundle.getSymbolicName());
 				}
 				
 				if (!StringUtils.isEmpty((String) bundle.getHeaders().get(MODEL_PACKAGE_HEADER))) {
 					bundlesToRegistPo.add(bundle);
 				}
 
 				//重新注册PO对象
 				if (CollectionUtils.isNotEmpty(bundlesToRegistPo) && CollectionUtils.isNotEmpty(sessionFactoryBeans)) {
 					logger.debug("call registerPOJO by bundleChanged");
 					registerPOJO();
 				}
 			} else if ((event.getType() & BundleEvent.STOPPED) != 0) { // 停止 Bundle 时
 				logger.info("STOPED => {}({})", bundle, bundle.getLastModified());
 				bundlesToRegistPo.remove(bundle);
 			}
 		}
 	}
 
 	/**
 	 * 注册自定义po对象
 	 */
 	private synchronized void registerPOJO() {
 		while (bundlesToRegistPo.size() > 0) {
 			parseBundleClasses();
 		}
 
 		try {
 			if (annotatedClassesMap.size() > 0) {
 				// 重新生成 sessionFactory
 				logger.info("rebuild session factory");
 
                 if(sessionFactoryAspect == null) {
                     if(sessionFactoryBeans.size() > 1)
                         throw new NoUniqueBeanDefinitionException(AnnotationSessionFactoryBean.class, sessionFactoryBeans.size(), "没有配置 "
                                 + GboatSessionFactoryAspect.class + " 切面，无法确定 POJO 与 SessionFactory 之间的对应关系，因而不支持多个 SessionFactory。");
                     
                     // 因为在 setApplicationContext(ApplicationContext applicationContext) 方法中已经判断了 sessionFactoryBeans 是否为空，
                     // 所以此处无需再对该集合进行非空判断，直接取值即可
                     AnnotationSessionFactoryBean bean = sessionFactoryBeans.iterator().next();
                     bean.destroy();
                     bean.setBeanClassLoader(gboatLoader);
                     bean.setAnnotatedClasses(registClasses.toArray(new Class[0]));
                     bean.afterPropertiesSet();
                     baseDAO.setDefaultSessionFactory(bean.getObject());
                 } else {
                     // 设置 POJO 与 SessionFactory 之间的映射关系
                     Map<SessionFactory, List<Class<?>>> sessionFactoryPojoMap = new HashMap<SessionFactory, List<Class<?>>>();
                     // 方法名、类名的正则表达式与 SessionFactory 之间的映射关系
                     Set<Entry<String, SessionFactory>> entrySet = sessionFactoryAspect.getTargetSessionFactorys().entrySet();
                     SessionFactory defaultSessionFactory = this.baseDAO.getDefaultSessionFactory();
                     SessionFactory matchSessionFactory = null;
                     List<Class<?>> tempList;
                     for(Class<?> clazz : registClasses) {
                         matchSessionFactory = null; // 在每次循环的开始将 matchSessionFactory 重置为 null
                         for (Entry<String, SessionFactory> entry : entrySet) {
                             if(clazz.getName().matches(entry.getKey())) {
                                 matchSessionFactory = entry.getValue();
                                 break;
                             }
                         }
                         
                         if(matchSessionFactory == null) {
                             matchSessionFactory = defaultSessionFactory;
                         }
 
                         tempList = sessionFactoryPojoMap.get(matchSessionFactory);
                         if(tempList == null){
                             tempList = new ArrayList<Class<?>>();
                             sessionFactoryPojoMap.put(matchSessionFactory, tempList);
                         }
                         tempList.add(clazz);
                     }
                     
                     // 根据 POJO 与 SessionFactory 之间的映射关系，将 POJO 分别注册到不同的 SessionFactory 中
                     SessionFactory oldSessionFactory = null;
                     SessionFactory newSessionFactory = null;
                     boolean isDefault = false;
                     for(AnnotationSessionFactoryBean bean : sessionFactoryBeans) {
                         oldSessionFactory = bean.getObject();
                         isDefault = oldSessionFactory.equals(baseDAO.getDefaultSessionFactory());
                         List<Class<?>> pojoList = sessionFactoryPojoMap.get(oldSessionFactory);
                         if(CollectionUtils.isNotEmpty(pojoList)){
                             bean.destroy();
                             bean.setBeanClassLoader(gboatLoader);
                             bean.setAnnotatedClasses(pojoList.toArray(new Class[0]));
                             bean.afterPropertiesSet();
                             
                             // 经过前面的操作之后，此处的 bean.getObject() 和之前的 sessionFactory 已经不是同一个实例了
                             newSessionFactory = bean.getObject();
                             baseDAO.addSessionFactory(newSessionFactory);
                             if (isDefault) {
                                 // 设置默认的 SessionFactory
                                 baseDAO.setDefaultSessionFactory(newSessionFactory);
                             }
                             
                             // 将切面中设置的 SessionFactory 也对应更新
                             for (Entry<String, SessionFactory> entry : entrySet) {
                                 if(oldSessionFactory.equals(entry.getValue())) {
                                     entry.setValue(newSessionFactory);
                                 }
                             }
                         }
                     }
                 }
                 // logger.debug("classes registered : " + registClasses);
 			}
 		} catch (Exception e) {
 		    logger.trace("Gboat2 DAO Bundle 注册 POJO 失败。", e);
 		}
 	}
 
 	private void parseBundleClasses() {
 		String[] importItems;
 		List<String> importClassNames;
 		// 处理本次包含注册 po 的 bundle
 		synchronized (bundlesToRegistPo) {
 			List<Class<?>> importClasses = null;
 			String importPath; // PO、VO 所在包的包名
 			for (Bundle bundle : bundlesToRegistPo) {
 				if (bundle == null)
 					continue;
 				
 				logger.debug("register po for {}", bundle.getSymbolicName());
 				importClasses = new ArrayList<Class<?>>();
 				if(bundlesCache.containsKey(bundle.getSymbolicName())){
 					//已经注册过的，清理之前添加的类
 					List<Class<?>> registedClasses = annotatedClassesMap.remove(bundle.getSymbolicName());
 					Class<?> clazz = null;
 					while(registedClasses != null && !registedClasses.isEmpty()){
 					    clazz = registedClasses.remove(0);
 						gboatLoader.remove(clazz.getName());
 					}
 				}
 				bundlesCache.put(bundle.getSymbolicName(), bundle);
 
 				importPath = (String) bundle.getHeaders().get(MODEL_PACKAGE_HEADER);
 				if (StringUtils.isEmpty(importPath)) { //path为空添加空集合
 					annotatedClassesMap.put(bundle.getSymbolicName(), importClasses);
 					continue;
 				} else {
 					// 处理import
 					logger.debug("dynamic import models : {}", importPath);
 					importItems = importPath.split(",");
 					for (String importItem : importItems) {
 						//判断 import 的是 class 还是 package
 						try {
 							Class<?> clazz = bundle.loadClass(importItem);
 							if (clazz != null) {
 								logger.debug("{} is a class", importItem);
 								importClasses.add(clazz);
 								continue;
 							}
 						} catch (ClassNotFoundException e1) {
 							logger.warn(e1.getMessage());
 							importClassNames = getClasses(importItem, bundle);
 							if (importClassNames.size() > 0) {
 								logger.debug("{} is a package, find classes in it is : {}", importItem, importClassNames);
 								for (String className : importClassNames) {
 									try {
 										//将load到的class放入List中
 										importClasses.add(bundle.loadClass(className));
 									} catch (ClassNotFoundException e) {
 										logger.debug(e.getMessage(), e.getCause());
 									}
 								}
 							}
 						}
 					}
 
 					//处理此bundle需要加载的类
 					annotatedClassesMap.put(bundle.getSymbolicName(), importClasses);
 				}
 				
 				for (Class<?> dealClass : importClasses) {
 					if (isEntity(dealClass)) {
 						registClasses.add(dealClass);
 					}
 					//将对应关系放入自定义classloader中
 					gboatLoader.add(dealClass.getName(), bundle);
 				}
 			}
 			bundlesToRegistPo.clear();
 		}
 	}
 
 	/**   
 	 * 获取 Bundle 指定包及其所有子包下所有类的名称（类的全限定名）
 	 * @param pack   要扫描的包
 	 * @param bundle bundle
 	 * @return   List
 	 */
 	public static List<String> getClasses(String pack, Bundle bundle) {
 		// class类的集合    
 		List<String> classes = new ArrayList<String>();
 		// 获取包的名字 并进行替换    
 		String packageName = pack;
 		String packageDirName = packageName.replace('.', '/');
 		try {
             URL url = bundle.getResource(packageDirName);
             if (url == null) // 防止配置的包不存在
                 return classes;
 
 			if (!"bundle".equals(url.getProtocol())) // 协议的名称不为 Bundle，直接返回
 			    return classes;
 			
 			// 获取包的物理路径   
 			String filePath = bundle.getLocation().replaceFirst("file:(/|\\\\)", "");
 			// 以文件的方式扫描整个包下的文件 并添加到集合中    
 			ZipInputStream in = null;
 			try {
 				in = new ZipInputStream(new FileInputStream(filePath));
 				ZipEntry entry = null;
 				String name;
 				while ((entry = in.getNextEntry()) != null) {
 					if (!entry.isDirectory()) {
 						name = entry.getName();
 						if (name.startsWith(packageDirName) && name.endsWith(".class")) {
 							classes.add(name.substring(0, name.indexOf(".class")).replaceAll("/", "."));
 						}
 					}
 				}
 			} catch (IOException e) {
 				throw new ClassNotFoundException("error : " + packageName + " the jar file [" + bundle + "] can't find");
 			} finally {
 			    IOUtils.closeQuietly(in);
 			}
 		} catch (Exception e) {
 		    logger.error("获取 Bundle[{}] 的 [{}] 包下所有类名发生错误。", bundle.getSymbolicName(), pack);
 			logger.error("", e);
 		}
 		return classes;
 	}
 
 	/**
 	 * 判断指定的 Java 类是否实体类，即当前类及其父类是否添加了 {@link javax.persistence.Entity} 注解
 	 * @param c Java类
 	 * @return 如果是实体类，则返回 true；反之则返回 false
 	 */
     private boolean isEntity(Class<?> c) {
         // 如果是接口、枚举或注解，则直接返回 false
         if(c.isInterface() || c.isEnum() || c.isAnnotation())
             return false;
 
         Entity e = c.getAnnotation(Entity.class);
         if (e != null)
             return true;
         
         c = c.getSuperclass();
         if (null == c || c.getName().equals(Object.class.getName()))
             return false;
 
         return isEntity(c);
     }
 
     public void setBaseDAO(IBaseDAO baseDAO) {
         this.baseDAO = baseDAO;
     }
 
     @Override
 	public void stop(BundleContext arg0) throws Exception {
 
 	}
 
 }