package gboat2.cxf.businessImpl;
   
   import gboat2.base.core.dao.QuerySupport;
   import gboat2.base.core.service.BaseService;
   import gboat2.cxf.Constant;
   import gboat2.cxf.business.IWebServiceConfigBusiness;
   import gboat2.cxf.model.WebServiceConfig;
   import gboat2.cxf.model.WebServiceConfigParam;
   
  import java.io.IOException;
  import java.net.InetAddress;
  import java.net.ServerSocket;
  import java.net.UnknownHostException;
  import java.util.Dictionary;
  import java.util.HashMap;
  import java.util.Hashtable;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang3.StringUtils;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.Constants;
  import org.osgi.framework.Filter;
  import org.osgi.framework.InvalidSyntaxException;
  import org.osgi.framework.ServiceReference;
  import org.osgi.framework.ServiceRegistration;
  import org.osgi.util.tracker.ServiceTracker;
  import org.osgi.util.tracker.ServiceTrackerCustomizer;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.osgi.context.BundleContextAware;
  import org.springframework.transaction.annotation.Transactional;
  
  @Transactional
  public class WebServiceConfigBusinessImpl extends BaseService implements IWebServiceConfigBusiness, BundleContextAware,
          ServiceTrackerCustomizer {
  	
  	private Logger logger = LoggerFactory.getLogger(WebServiceConfigBusinessImpl.class);
  	
  	private BundleContext bc;
  	
  	private volatile boolean initAddressSign = Boolean.FALSE;
  	
  	private String hostName = null;
  	
  	private String port = null;
  	
  	private static Map<String, ServiceRegistration<?>> publishedWebServices = new Hashtable<String, ServiceRegistration<?>>();
  	
  	//所有要发布成webserivce的接口都需要被监听，需监听的列表存储在被数据Map中
  	private static Map<String, WebServiceConfig> interfacesToListening = new Hashtable<String, WebServiceConfig>();
  	
  	private static ServiceTracker tracker;
  	
  	private static byte[] lock = new byte[0];
  	
  	private void initInterfacesToListening() {
  		//		boolean isNotActive = false;
  		//		for (Bundle b : bc.getBundles()) {
  		//			if (b.getSymbolicName().equals("gboat2.base.dao")) {
  		//				if ((b.getState() & Bundle.ACTIVE) == 0) {
  		//					isNotActive = true;
  		//				}
  		//			}
  		//		}
  		List<WebServiceConfig> webSerConfigList = getActiveWebServiceConfigs();
  		
  		//		if (isNotActive || null == webSerConfigList || webSerConfigList.size() == 0) {
  		//			System.out.print("dao还没起来");
  		//		}
  		
  		//缓存所有要发布的接口
  		if (null != webSerConfigList) {
  			for (WebServiceConfig config : webSerConfigList) {
  				interfacesToListening.put(config.getInterfaceName(), config);
  			}
  		}
  	}
  	
  	@SuppressWarnings({ "rawtypes", "unchecked" })
      @Override
  	public Object addingService(ServiceReference ref) {
  		String[] interfaceNames = (String[]) ref.getProperty(Constants.OBJECTCLASS);
  		boolean isPublishedService = (null != ref.getProperty(EXPORTED_INTERFACES)); //过滤掉已发布服务导致的add事件
  		
  		if (!isPublishedService && null != interfaceNames && interfaceNames.length != 0) {
  			WebServiceConfig config = interfacesToListening.get(interfaceNames[0]);
  			if (null != config) {//刚添加的服务在监视列表中，则发布该服务
  				publishService(config);
  			}
  		}
  		return bc.getService(ref);
  	}
  	
  	@SuppressWarnings("rawtypes")
      @Override
  	public void modifiedService(ServiceReference sref, Object service) {
  	}
  	
 	@SuppressWarnings("rawtypes")
     @Override
 	public void removedService(ServiceReference sref, Object service) {
 		String[] interfaceNames = (String[]) sref.getProperty(Constants.OBJECTCLASS);
 		boolean isPublishedService = null != sref.getProperty(EXPORTED_INTERFACES); //过滤掉已发布服务导致的remove事件
 		if (!isPublishedService && null != interfaceNames && interfaceNames.length != 0) {
 			String interfaceName = interfaceNames[0];
 			if (interfacesToListening.containsKey(interfaceName)) { // 发布的服务被删除，登记的服务需要移除
 				publishedWebServices.remove(interfaceName);
 			}
 		}
 	}
 	
 	@SuppressWarnings({ "unchecked", "rawtypes" })
     @Override
 	public void startPublishAndTrackWebService() {
 	    // 只在第一次实例化 bean 对象时打开追踪器
 		synchronized (lock) {//锁定tracker再进行判断
 			if (null != tracker) {
 				return;
 			}
 		}
 		
 		initInterfacesToListening();
 		
 		Filter filter = null;
 		try {
 			filter = bc.createFilter("(objectClass=*)");
 		} catch (InvalidSyntaxException e) {
 			logger.error("CXF webService 监听过滤器语法错误", e);
 			throw new IllegalArgumentException("unexpected InvalidSyntaxException: " + e.getMessage());
 		}
 		tracker = new ServiceTracker(bc, filter, this);
 		tracker.open();
 	}
 	
 	//	public boolean publishAllServicesIf() {
 	//		boolean isPublished = true;
 	//		List<WebServiceConfig> webSerConfigList = getActiveWebServiceConfigs();
 	//		if (null != webSerConfigList) {
 	//			for (WebServiceConfig config : webSerConfigList) {
 	//				//if (!serviceRegs.containsKey(config.getInterfaceName())) {
 	//				ServiceRegistration tempSerReg = publishService(config);
 	//				if (tempSerReg == null) {
 	//					isPublished = false;
 	//				}
 	//				//}
 	//			}
 	//		}
 	//		
 	//		return isPublished;
 	//	}
 	
 	private List<WebServiceConfig> getActiveWebServiceConfigs() {
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put(QuerySupport.PARAM_TABLENAME, WebServiceConfig.class.getName());
 		//params.put("_status", Constant.WEBSERVICE_STATUS_ACTIVE);
 		return (List<WebServiceConfig>) super.query(params);
 	}
 	
 	/**
 	 * 本方法可以在cxf osgi bundle启动前调用，因为该bundle启动后会扫描发布的服务并启动他们。故在调用本方法前无需检测
 	 * cxf osgi bundle是否已经启动
 	 */
 	public ServiceRegistration publishService(WebServiceConfig config) {
 		if (StringUtils.isEmpty(config.getInterfaceName())) {
 			logger.error("webserivce 记录中interfaceName为空，configId:" + config.getConfigId());
 			return null;
 		}
 		String newAddress = getWebserviceReleaseAddress() + config.getRelativeAddress();
 		Dictionary<String, String> props = new Hashtable<String, String>();
         props.put(EXPORTED_INTERFACES, "*");
         props.put(EXPORTED_CONFIGS, "org.apache.cxf.ws");
         props.put(WS_ADDRESS, newAddress);
 
         ServiceRegistration<?> serviceReg = publishedWebServices.get(config.getInterfaceName());
         if (null == serviceReg) { // 未曾发布过
             ServiceReference<?> serviceRef = bc.getServiceReference(config.getInterfaceName());
             Object serviceObj = bc.getService(serviceRef);
             if (serviceObj != null) {
                 // 注册服务
                 serviceReg = bc.registerService(config.getInterfaceName(), serviceObj, props);
             }
         } else { // 已经发布过了，则更新
             // if (!newAddress.equals(serviceReg.getReference().getProperty(REMOTE_POJO_ADDREASS_PROPERTY))) {// 地址更改过
             if (!newAddress.equals(serviceReg.getReference().getProperty(WS_ADDRESS))) { // 地址更改过
                 Object objImpl = bc.getService(serviceReg.getReference());
                 serviceReg.unregister(); // 注销原来发布过的服务
                 serviceReg = bc.registerService(config.getInterfaceName(), objImpl, props);// 重新注册成服务
             }
         }
 		//添加到注册列表
 		publishedWebServices.put(config.getInterfaceName(), serviceReg);
 		
 		if (!Constant.WEBSERVICE_STATUS_ACTIVE.equals(config.getStatus())) {
 			config.setStatus(Constant.WEBSERVICE_STATUS_ACTIVE); // 设定库中数据状态为激活
 			update(config);
 		}
 		
 		// 发布后的服务需要加入到监听列表，以确保相应服务重启后会自动发布
 		interfacesToListening.put(config.getInterfaceName(), config);
 		return serviceReg;
 	}
 	
 	public void unpublishService(WebServiceConfig config) {
 		Dictionary props = new Hashtable();
 		interfacesToListening.remove(config.getInterfaceName()); //必须在重新注册服务前移除监听列表，否则可能导致重新发布
 		ServiceReference serviceRef = bc.getServiceReference(config.getInterfaceName());
 		if (null != serviceRef) {
 			Object objImpl = bc.getService(serviceRef);
 			ServiceRegistration regist = publishedWebServices.get(config.getInterfaceName());
 			if (null != regist) {
 				regist.unregister();
 				bc.registerService(config.getInterfaceName(), objImpl, props);//注销后需要重新注册成普通服务
 			}
 		}
 		publishedWebServices.remove(config.getInterfaceName());
 		
 		if (!Constant.WEBSERVICE_STATUS_INACTIVE.equals(config.getStatus())) {
 			config.setStatus(Constant.WEBSERVICE_STATUS_INACTIVE);//设定库中数据状态为不激活
 			update(config);
 		}
 	}
 	
 	@Override
 	public boolean delete(Object po) {
 		this.unpublishService((WebServiceConfig) po);
 		this.baseDAO.delete(po);
 		return true;
 	}
 	
 	public void setBundleContext(BundleContext bct) {
 		bc = bct;
 	}
 	
 	//	public void unpublishAllServices() {
 	//		if (bc.getBundle().getState() == Bundle.ACTIVE) {
 	//			Set<String> regKeys = publishedWebServices.keySet();
 	//			for (String key : regKeys)
 	//				unpublishService(key);
 	//		}
 	//	}
 	
 	public WebServiceConfigParam getWebSerConfParam(String key) {
 		Map<String, Object> params = new HashMap<String, Object>();
 		WebServiceConfigParam returnParam = null;
 		params.put("TABLENAME", WebServiceConfigParam.class.getName());
 		params.put("_paramKey", key);
 		List webSerConfParams = super.query(params);
 		if ((webSerConfParams != null) && (webSerConfParams.size() > 0)) {
 			returnParam = (WebServiceConfigParam) webSerConfParams.get(0);
 		}
 		return returnParam;
 	}
 	
 	/**
 	 * 
 	 * 获取web service发布地址
 	 * @return
 	 */
 	private String getWebserviceReleaseAddress() {
 		initWebServiceAddress();
 		return hostName + ":" + port + "/";
 	}
 	
 	/**
 	 * 初始化web service地址
 	 */
 	private void initWebServiceAddress() {
 		if (!initAddressSign) {
 			WebServiceConfigParam mainAddressParam = getWebSerConfParam(SITE_ADDRESS_KEY);
 			WebServiceConfigParam portParam = getWebSerConfParam(PORT_KEY);
 			//域名（IP）处理
 			if (null != mainAddressParam) {
 				hostName = mainAddressParam.getParamValue();
 			} else {
 				hostName = "http://" + getHost();
 				WebServiceConfigParam newAddressParam = new WebServiceConfigParam();
 				newAddressParam.setParamKey(SITE_ADDRESS_KEY);
 				newAddressParam.setParamValue(hostName);
 				super.save(newAddressParam);
 			}
 			//端口处理
 			if (null != portParam) {
 				//port = portParam.getParamValue();
 				port = getEnabledPort(portParam.getParamValue());
 				if (port != null && !portParam.getParamValue().equals(port)) {
 					portParam.setParamValue(port);
 					super.update(portParam);
 				}
 			} else {
 				//port = PORT_VALUE;
 				port = getEnabledPort(PORT_VALUE);
 				WebServiceConfigParam newPortParam = new WebServiceConfigParam();
 				newPortParam.setParamKey(PORT_KEY);
 				newPortParam.setParamValue(port);
 				super.save(newPortParam);
 			}
 			initAddressSign = true;
 		}
 	}
 	
 	//获取合理port
 	private String getEnabledPort(String port) {
 		//先试默认的
 		String returnPort = tryPortFree(port);
 		/*Integer nextPort = Integer.parseInt(port);
 		//如果传入的系统当前配置端口不合法，则试试比其大1的端口
 		while (null == returnPort) {
 			nextPort = nextPort + 1;
 			if (null != tryPortFree(nextPort + "")) {
 				returnPort = nextPort + "";
 			}
 		}*/
 		return returnPort;
 	}
 	
 	//查看某个端口是否可用
 	private String tryPortFree(String port) {
 		int p = Integer.parseInt(port);
 		ServerSocket s = null;
 		try {
 			s = new ServerSocket(p);
 			return "" + s.getLocalPort();
 		} catch (IOException e) {
 			logger.error("port " + port + " is already used.");
 			return null;
 		} finally {
 			if (s != null)
 				try {
 					s.close();
 				} catch (IOException e) {
 					e.printStackTrace();
 				}
 		}
 	}
 	
 	/**
 	 * 获取当前主机名
 	 * @return
 	 */
 	private String getHost() {
 		try {
 			InetAddress addr = InetAddress.getLocalHost();
 			return addr.getHostAddress();
 		} catch (UnknownHostException e) {
 			e.printStackTrace();
 		}
 		return null;
 	}
 	
 	@Override
 	public boolean decideCurrentService(String expPckNamesString, String serviceName) {
 		String servicePackageName = serviceName.substring(0, serviceName.lastIndexOf("."));
 		if (expPckNamesString.indexOf(servicePackageName) >= 0) {
 			return true;
 		}
 		return false;
 	}
 	
 }