package com.vci.client.omd.provider;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.vci.corba.omd.atm.AttPoolServicePrx;
import com.vci.corba.omd.atm.AttribItem;
import com.vci.corba.omd.etm.EnumItem;
import com.vci.client.common.ClientLog4j;
import com.vci.client.common.providers.ServiceProvider;
import com.vci.corba.common.VCIError;
import com.vci.omd.constants.OmdConstants;
import com.vci.omd.dataType.VTDataType;
import com.vci.omd.objects.OtherInfo;

public class ApProvider {
	private static ApProvider apProvider = null;
	
	private ApProvider(){
		
	}
	
	public static ApProvider getInstance(){
		if(apProvider == null){
			apProvider = new ApProvider();
		}
		return apProvider;
	}
	
	private static AttPoolServicePrx getService(){
		try {
			return ServiceProvider.getOMDService().getAttributeService();
		} catch (Exception e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		return null;
	}
	/**
	 * 根据多个属性名获取多个属性
	 * @param abNames
	 * @return
	 */
	public static AttribItem[] getAttribItemsByNames(String[] abNames){
		AttribItem[] attribItems = null;
		try {
			attribItems = getService().getAttribItemsByNames(abNames);
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		if(attribItems == null){
			attribItems = new AttribItem[0];
		}
		return attribItems;
	}
	
	/**
	 * 获取指定的属性
	 * @param abName
	 * @return
	 */
	public static AttribItem getAbItemByName(String abName){
		AttribItem abItem = null;
		try {
			abItem = getService().getAttribItemByName(abName);
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		return abItem;
	}
	
	/**
	 * 获取全部属性
	 * @return
	 */
	public static AttribItem[] getAllAbItems(){
		AttribItem[] abArray = null;
		try {
			abArray = getService().getAttribItems("", 1, 1);
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		return abArray;
	}
	/**
	 * 获取属性的数据类型
	 * @param abName
	 * @return
	 */
	public static String getAbItemDataType(String abName){
		String dataType = null;
		String abUpperName = abName.toUpperCase();
		//系统属性
		if(abUpperName.equals("OID") || abUpperName.equals("REVISIONOID") || abUpperName.equals("NAMEOID") || abUpperName.equals("BTMNAME")
				|| abUpperName.equals("CREATOR") || abUpperName.equals("LASTMODIFIER") || abUpperName.equals("REVISIONRULE")
				|| abUpperName.equals("VERSIONRULE") || abUpperName.equals("REVISIONVALUE") || abUpperName.equals("VERSIONVALUE")
				|| abUpperName.equals("LCTID") || abUpperName.equals("LCSTATUS")
				|| abUpperName.equals("ID") || abUpperName.equals("NAME") || abUpperName.equals("DESCRIPTION") 
				|| abUpperName.equals("OWNER") || abUpperName.equals("CHECKINBY") 
				|| abUpperName.equals("CHECKOUTBY") || abUpperName.equals("COPYFROMVERSION")
				|| abUpperName.equals("ISLASTR") || abUpperName.equals("ISFIRSTR")
				|| abUpperName.equals("ISLASTV") || abUpperName.equals("ISFIRSTV")
				|| abUpperName.equals("F_OID") || abUpperName.equals("F_REVISIONOID") 
				|| abUpperName.equals("F_NAMEOID") || abUpperName.equals("F_BTWNAME")
				|| abUpperName.equals("T_OID") || abUpperName.equals("T_REVISIONOID") 
				|| abUpperName.equals("T_NAMEOID") || abUpperName.equals("T_BTWNAME")){
			dataType = "VTString";
		}else if(abUpperName.equals("REVISIONSEQ") || abUpperName.equals("VERSIONSEQ")){
			dataType = "VTInteger";
		}else if(abUpperName.equals("CREATETIME") || abUpperName.equals("LASTMODIFYTIME")
				|| abUpperName.equals("TS") || abUpperName.equals("CHECKINTIME") || abUpperName.equals("CHECKOUTTIME")){
			dataType = "VTDateTime";
		//属性池中属性
		}else{		
			try {
				dataType = getService().getAttribItemDataType(abName);
			} catch (VCIError e) {
				//e.printStackTrace();
				ClientLog4j.logger.error(e);
			}
		}
		return dataType;
	}
	
	/**
	 * 提供（对外）属性池的数据文件数据
	 * @return
	 */
	public static String getAPData(){
		String content = "";
		try {
			content = getService().getAPData();
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		return content;
	}

	/**
	 * 获取other中指定项目的值
	 * @return
	 */
	public static String getOtherValueByType(String other, String type){
		String[] otherArray = other.split(";");
		for(int i = 0; i < otherArray.length; i++){
			String otherValue = otherArray[i];
			if(otherValue.contains(type)){
				return otherValue.substring(otherValue.indexOf("=") + 2, otherValue.length());
			}
		}
		return null;
	}
	
	/**
	 * 检查属性类型与属性值是否匹配
	 * @param vtType
	 * @param value
	 * @return
	 */
	public static boolean checkDataType(String vtType, String value){
		
		if(vtType.equals(VTDataType.VTSTRING)){
			try{
				String.valueOf(value);
			}catch(Exception e){
				return false;
			}
		}else if(vtType.equals(VTDataType.VTINTEGER)){
			try{
				Integer.valueOf(value);
			}catch(Exception e){
				return false;
			}
		}else if(vtType.equals(VTDataType.VTLONG)){
			try{
				Long.valueOf(value);
			}catch(Exception e){
				return false;
			}
		}else if(vtType.equals(VTDataType.VTDOUBLE)){
			try{
				Double.valueOf(value);
			}catch(Exception e){
				return false;
			}
		}
	
		return true;
	}
	
	public static boolean expData(String dir, AttribItem[] objs) {
		Set<String> enumNames = new HashSet<String>();
		List<EnumItem> enums = new ArrayList<EnumItem>();
		BufferedWriter bw = null;
		FileOutputStream fos = null;
		OutputStreamWriter osw =null;
		try{
			File file = new File(dir + "/att.txt");
			//将clob字段写到单独的文件中
			if(!file.exists()){
				new File(dir + "/att").mkdir();
			}
			//add by caill start 2015.12.23 	导出时将txt文件设置为“utf-8”格式
			fos = new FileOutputStream(file,true);
			osw = new OutputStreamWriter(fos, "utf-8");
			bw = new BufferedWriter(osw);
			//add by caill end
			//w = new FileWriter(file, true);
			//bw = new BufferedWriter(w);
			for(AttribItem o : objs){
				OtherInfo otherInfo = OtherInfo.getOtherInfoByText(o.other);
				String enumName = otherInfo.getEnumName();
				if(enumName != null && !enumName.equals("")){
					enumNames.add(enumName);
				}
				//若str小于缓冲区大小, 将写到缓冲区; 
				//若str大于缓冲区大小, 将刷新缓冲区(将缓冲区内容写到底层流), 然后str直接写到底层流.
				String text = getObjectText(o);
				bw.write(text);
				bw.newLine();
				BufferedWriter clobBW = null;
				FileOutputStream fo = null;
				OutputStreamWriter pw =null;
				try{
					File clobFile = new File(dir + "/att/" + o.oid + ".xml");
					//add by caill start 2015.12.23 将xml内容和xml文件格式统一
				    fo = new FileOutputStream(clobFile);
					pw = new OutputStreamWriter(fo, "utf-8");
					clobBW = new BufferedWriter(pw);
					clobBW.write( "<?xml version=\"1.0\" encoding=\"utf-8\" ?>");//gb2312
					clobBW.write(getXmlText(o));
					clobBW.flush();
					//add by caill end	
				}catch(IOException e2){
					e2.printStackTrace();
				}finally{
					try{
						if(clobBW != null){
							fo.close();		//add by caill 2015.12.16 将fo关闭
							pw.close();		//add by caill 2015.12.16 将pw关闭
							clobBW.close();
						}
					} catch (IOException e) {
						//e.printStackTrace();
						ClientLog4j.logger.error(e);
					}
				}
			}
			bw.flush();
			for(String name : enumNames){
				EnumItem emItem = EnumProvider.getInstance().getService().getEmItemByName(name);
				enums.add(emItem);
			}
			boolean flag = EnumProvider.getInstance().expData(dir, enums.toArray(new EnumItem[0]));
			ClientLog4j.logger.info("**************属性池导出成功************");
			return true & flag;
		}catch(IOException e){
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}finally{
			try {
				if(bw != null){
					fos.close();	//add by caill 2015.12.23  将fos关闭
					osw.close();	//add by caill 2015.12.23  将osw关闭
					bw.close();
				}
			} catch (IOException e) {
				//e.printStackTrace();
				ClientLog4j.logger.error(e);
			}
		}
		ClientLog4j.logger.warn("**************属性池导出失败************");
		return false;
	}
	
	
	/**
	 * 将对象转化成字符串
	 * {oid:qqq, name:q}
	 * @param o
	 * @return
	 */
	public static String getObjectText(AttribItem o) {
		StringBuilder stb = new StringBuilder("{");
		stb.append(OmdConstants.OID + ":" + o.oid + ",");
		stb.append(OmdConstants.NAME + ":" + o.name + ",");
		stb.append(OmdConstants.LABEL + ":" + o.label + ",");
		stb.append(OmdConstants.DESCRIPTION + ":" + o.description + ",");
		stb.append(OmdConstants.TS + ":" + o.ts + ",");
		stb.append(OmdConstants.CREATOR + ":" + o.creator + ",");
		stb.append(OmdConstants.CREATETIME + ":" + o.createTime + ",");
		stb.append(OmdConstants.MODIFIER + ":" + o.modifier + ",");
		stb.append(OmdConstants.MODIFYTIME + ":" + o.modifyTime);
		stb.append("}");
		return stb.toString();
	}
	
	/**
	 * 将att转化成xmltext
	 * @param bt
	 * @return
	 */
	public static String getXmlText(AttribItem att) {
		StringBuilder stb = new StringBuilder("<attribute>");
		stb.append("<name>" + att.name + "</name>");
		stb.append("<label>" + att.label + "</label>");
		stb.append("<description>" + att.description + "</description>");
		stb.append("<vtDataType>" + att.vtDataType + "</vtDataType>");
		stb.append("<defValue>" + att.defValue + "</defValue>");
		stb.append("<rage>" + att.rage + "</rage>");
		stb.append("<other>" + att.other + "</other>");
		stb.append("</attribute>");
		return stb.toString();
	}

	public static List<AttribItem> getAttFromFile(String dir) {
		File file = new File(dir + "/att.txt");
		List<AttribItem> list = new ArrayList<AttribItem>();
		BufferedReader br = null;
		FileInputStream fo = null;
		InputStreamReader isw =null;
		try {
			/*r = new FileReader(file);
			br = new BufferedReader(r);*/
			//add by caill start 2015.12.23 	导入时将txt文件内容设置为“utf-8”格式
		    fo = new FileInputStream(file);
			isw = new InputStreamReader(fo, "utf-8");
			br = new BufferedReader(isw);
			//add by caill end
			String str = null;
			while((str = br.readLine()) != null){
				Map<String, String> map = getMapFormText(str);
				String oid = map.get("oid");
				if(oid != null && !oid.equals("")){
					File contentFile = new File(dir + "/att/" + oid + ".xml");
					if(!contentFile.exists()){
						ClientLog4j.logger.info(dir + "/att/" + oid + ".xml不存在");
						break;
					}
					AttribItem att = new AttribItem();
					att.oid = oid;
					att.name = map.get("name");
					att.label = map.get("label");
					att.description = map.get("description");
					att.ts = map.get("ts");
					att.creator = map.get("creator");
					att.createTime = Long.valueOf(map.get("createTime"));
					att.modifier = map.get("modifier");
					att.modifyTime = Long.valueOf(map.get("modifyTime"));
					SAXReader sa = new SAXReader();
					//add by caill 2015.12.23	导入时将saxReader对象设置为“utf-8”格式
					sa.setEncoding("utf-8");
					Document document = sa.read(contentFile);
					setAttValueFormDoc(att, document.getRootElement());
					list.add(att);
				}else{
					ClientLog4j.logger.info(dir + "att.txt中存在oid为空的错误记录");
					break;
				}
			}
			return list;
		} catch (FileNotFoundException e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		} catch (IOException e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		} catch (DocumentException e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		} finally{
			if(br != null){
				try {
					fo.close();		//add by caill 2015.12.23	将fo关闭
					isw.close();	//add by caill 2015.12.23	将isw关闭
					br.close();
				} catch (IOException e) {
					//e.printStackTrace();
					ClientLog4j.logger.error(e);
				}
			}
		}
		return null;
	}
	/**
	 * 将文件中一条记录解析成key-value
	 * @param str
	 * @return
	 */
	public static Map<String, String> getMapFormText(String str) {
		str = str.trim();
		if(!str.startsWith("{") || !str.endsWith("}")){
			return null;
		}
		Map<String, String> map = new HashMap<String, String>();
		str = str.substring(1, str.length() - 1);
		String[] kvs = str.split(",");
		for(String kv : kvs){
			String[] kv_ = kv.split(":");
			if(kv_.length == 1){
				map.put(kv_[0].trim(), "");	
			}else{
				map.put(kv_[0].trim(), kv_[1].trim());
			}
		}
		return map;
	}
	
	/**
	 * 设置EnumItem存在
	 * @param att
	 * @param element
	 */
	private static void setAttValueFormDoc(AttribItem att, Element element){
		String value = element.elementText("vtDataType");
		att.vtDataType = (value == null ? "" : value);
		value = element.elementText("defValue");
		att.defValue = (value == null ? "" : value);
		value = element.elementText("rage");
		att.rage = (value == null ? "" : value);
		value = element.elementText("other");
		att.other = (value == null ? "" : value);
	}
	
	public static boolean impData(String dir, AttribItem[] atts) {
		try {
			List<EnumItem> enums = EnumProvider.getInstance().getEnumsFromFile(dir);
			boolean enumFlag = EnumProvider.getInstance().impData(enums.toArray(new EnumItem[0]));
			if(!enumFlag){
				ClientLog4j.logger.info("属性池使用的枚举导入失败。导入中止。");
				return false;
			}
			for(AttribItem att : atts){
				AttribItem att_ = getService().getAttribItemByName(att.name);
				//已经存在
				if(!att_.oid.equals("")){
					//类型一致则覆盖
					if(att.vtDataType.equals(att_.vtDataType)){
						getService().deleteAbItem(att_);
						getService().addAttribItem(att);
						ClientLog4j.logger.info(att.name + "在数据库中已经存在，且类型与文件中的一致。 覆盖。");
					//类型不一致则中止导入
					}else{
						ClientLog4j.logger.info(att.name + "在数据库中已经存在，且类型与文件中的不一致。 中止导入。");
						return false;
					}
				}else{
					getService().addAttribItem(att);
				}
			}
			return true;
		} catch (VCIError e) {
			//e.printStackTrace();
			ClientLog4j.logger.error(e);
		}
		return false;
	}
}