package com.vci.client.portal.Formdesign;

import java.awt.AlphaComposite;
import java.awt.Component;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragSource;
import java.awt.dnd.DragSourceDragEvent;
import java.awt.dnd.DragSourceDropEvent;
import java.awt.dnd.DragSourceEvent;
import java.awt.dnd.DragSourceListener;
import java.awt.dnd.DropTargetDragEvent;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.dnd.DropTargetEvent;
import java.awt.dnd.DropTargetListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.swing.JLabel;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import com.vci.client.omd.btm.wrapper.BtmItemWrapper;
import com.vci.client.omd.linktype.LinkTypeWrapper;
import com.vci.client.omd.provider.ApProvider;
import com.vci.client.omd.provider.BtmProvider;
import com.vci.client.omd.provider.LinkTypeProvider;
import com.vci.client.portal.Formdesign.object.MTransferable;
import com.vci.client.ui.swing.VCISwingUtil;
import com.vci.client.ui.tree.VCIBaseTreeModel;
import com.vci.client.ui.tree.VCIBaseTreeNode;
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.atm.AttribItem;
import com.vci.corba.omd.ltm.LinkType;
import com.vci.omd.constants.SystemAttribute;
import com.vci.omd.objects.OtherInfo;

class DragTree extends JTree implements DragGestureListener, DragSourceListener, DropTargetListener {

	/**
	 * 业务对象名称
	 */
	private String btName;
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	BufferedImage ghostImage;

	private Rectangle2D ghostRect = new Rectangle2D.Float();

	private Point ptOffset = new Point();

	private Point lastPoint = new Point();

	private TreePath lastPath;

//	private Timer hoverTimer;

//	FileNode sourceNode;
	VCIBaseTreeNode sourceNode;
	private Object selectTreeNodeobject;

	public DragTree(Object object, String btName) {
		this.btName = btName;
		this.selectTreeNodeobject = object;
		DragSource dragSource = DragSource.getDefaultDragSource();

		dragSource.createDefaultDragGestureRecognizer(this, // component where
				// drag originates
				DnDConstants.ACTION_COPY_OR_MOVE, // actions
				this); // drag gesture recognizer
		try {
			if (selectTreeNodeobject instanceof BtmItemWrapper) {
				setModel(createTreeModel());
			} else if (selectTreeNodeobject instanceof LinkTypeWrapper) {
				setModel(createLinktypeTreeModel());
			}

		} catch (VCIError e) {
			e.printStackTrace();
		}

		addTreeExpansionListener(new TreeExpansionListener() {
			public void treeCollapsed(TreeExpansionEvent e) {
			}

			public void treeExpanded(TreeExpansionEvent e) {
				TreePath path = e.getPath();

				if (path != null) {
//					FileNode node = (FileNode) path.getLastPathComponent();
					VCIBaseTreeNode node = (VCIBaseTreeNode) path.getLastPathComponent();
//					if (!node.isExplored()) {
//						DefaultTreeModel model = (DefaultTreeModel) getModel();
//						node.explore();
//						model.nodeStructureChanged(node);
//					}
				}
			}
		});
		this.setCellRenderer(new DefaultTreeCellRenderer() {

			public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
					boolean leaf, int row, boolean hasFocus) {

				super.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);

				TreePath tp = tree.getPathForRow(row);
				if (tp != null) {
					VCIBaseTreeNode node = (VCIBaseTreeNode) tp.getLastPathComponent();

					if (node.isLeaf()) {
						Object obj = node.getObj();
						
						if (obj != null && obj instanceof AttributeNode) {
							AttributeNode anode = (AttributeNode)obj;
							if (anode.isSys())
								setIcon(VCISwingUtil.createImageIcon("sysattribute.png"));
							else
								setIcon(VCISwingUtil.createImageIcon("attribute.png"));
						}
						else
							setIcon(VCISwingUtil.createImageIcon("attribute.png"));
					}

//					Object obj = node.getObj();
//					if (obj instanceof AttribItem){
//						setIcon(VCISwingUtil.createImageIcon("attribute.png"));
//					}
				}

				return this;
			}

		});

		super.setScrollsOnExpand(true);
	}

	public void dragGestureRecognized(DragGestureEvent e) {
		// drag anything ...
		TreePath path = getLeadSelectionPath();
		if (path == null)
			return;
		VCIBaseTreeNode node = (VCIBaseTreeNode) path.getLastPathComponent();
		sourceNode = node;
		// Work out the offset of the drag point from the TreePath bounding
		// rectangle origin
		Rectangle raPath = getPathBounds(path);
		Point ptDragOrigin = e.getDragOrigin();
		ptOffset.setLocation(ptDragOrigin.x - raPath.x, ptDragOrigin.y - raPath.y);
		// Get the cell renderer (which is a JLabel) for the path being dragged
		int row = this.getRowForLocation(ptDragOrigin.x, ptDragOrigin.y);
		JLabel lbl = (JLabel) getCellRenderer().getTreeCellRendererComponent(this, // tree
				path.getLastPathComponent(), // value
				false, // isSelected (dont want a colored background)
				isExpanded(path), // isExpanded
				getModel().isLeaf(path.getLastPathComponent()), // isLeaf
				row, // row (not important for rendering)
				false // hasFocus (dont want a focus rectangle)
		);
		lbl.setSize((int) raPath.getWidth(), (int) raPath.getHeight()); // <--
		// The
		// layout
		// manager
		// would
		// normally
		// do
		// this

		// Get a buffered image of the selection for dragging a ghost image
		this.ghostImage = new BufferedImage((int) raPath.getWidth(), (int) raPath.getHeight(),
				BufferedImage.TYPE_INT_ARGB_PRE);
		Graphics2D g2 = ghostImage.createGraphics();

		// Ask the cell renderer to paint itself into the BufferedImage
		g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC, 0.5f));
		// Make the image ghostlike
		lbl.paint(g2);

		g2.dispose();
		// this.getGraphics().drawImage(ghostImage, e.getDragOrigin().x,
		// e.getDragOrigin().y, this);

//		e.startDrag(
//				null, // cursor
//				ghostImage, new Point(5, 5),
//				new StringSelection(getFilename()), // transferable
//				this); // drag source listener
		e.startDrag(DragSource.DefaultMoveDrop, getAttrItem(), this);
	}

	public void dragDropEnd(DragSourceDropEvent e) {
		ghostImage = null;
		sourceNode = null;
	}

	public void dragEnter(DragSourceDragEvent e) {
	}

	public void dragExit(DragSourceEvent e) {
		if (!DragSource.isDragImageSupported()) {
			repaint(ghostRect.getBounds());
		}
	}

	public void dragOver(DragSourceDragEvent e) {

	}

	public void dropActionChanged(DragSourceDragEvent e) {
	}

	/**
	 * 获取业务类型属性信息
	 * 
	 * @return
	 */
	public MTransferable getAttrItem() {
		TreePath path = getLeadSelectionPath();
		VCIBaseTreeNode node = (VCIBaseTreeNode) path.getLastPathComponent();
		Object obj = node.getObj();
//		if (obj instanceof AttributeNode) {
//			obj = (AttributeNode) obj;
//		}
//		else if (obj instanceof SysAttribute) {
//			obj = ((SysAttribute)obj).getAttrItem();
//		}
//		else if (obj instanceof String) {
//			obj = (String) obj;
//		}
		MTransferable mt = new MTransferable(obj);
		return mt;
	}

	private DefaultTreeModel createTreeModel() throws VCIError {
		AttribItem[] btAbItems = BtmProvider.getInstance().getBtAbItems(btName);
		// String[] sysAbItems = BtmProvider.getInstance().getSysAbItems();
		AttribItem[] sysAbItems = BtmProvider.getInstance().getSysAttribItems();

		VCIBaseTreeNode rootNode = new VCIBaseTreeNode("【" + btName + "】属性信息", "root");
		VCIBaseTreeModel treeModel = new VCIBaseTreeModel(rootNode);
		String nodeName;
		for (int i = 0; i < btAbItems.length; i++) {

			AttribItem item = btAbItems[i];
			nodeName = item.name.toLowerCase();

			addNode(rootNode, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, item, false)));
		}
		for (int i = 0; i < sysAbItems.length; i++) {

			AttribItem item = sysAbItems[i];
			nodeName = item.name.toLowerCase();

			addNode(rootNode, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, item, true)));
		}

		rootNode.setExpand(true);
		return new DefaultTreeModel(rootNode);
	}

	private void addNode(VCIBaseTreeNode pNode, VCIBaseTreeNode node) {
		if (pNode.getPath().length >= 4) {
			return;
		}

		pNode.add(node);
		if (node.getPath().length >= 4) {
			node.setLeaf(true);
			return;
		}

		Object obj = node.getObj();
		//String abName = (String) node.getUserObject();
		AttribItem abItem = null;
		String abName = "";
		
		if (obj instanceof AttributeNode) {
			abItem = ((AttributeNode)obj).getAttrItem();
			abName = ((AttributeNode)obj).getName();
		} else if (obj instanceof AttribItem) {
			abItem = (AttribItem)obj;
			abName = abItem.name;
		} else if (obj instanceof String) {
			abName = (String)obj;
		} 
		
		if (abItem == null)
			return;
		
		// 取node上的最后一个属性名
		if (abName.contains(".")) {
			abName = abName.substring(abName.lastIndexOf(".") + 1);
		}

		if (abName.equals("f_oid") || abName.equals("t_oid")) {
			return;
		}

		if (SystemAttribute.sysAttList().contains(abName.toUpperCase())) {
			node.setLeaf(true);
			return;
		}

//		AttribItem abItem = (AttribItem) node.getObj();// ApProvider.getInstance().getAbItemByName(abName);

		// abItem = APClient.getService().getAttribItemByName(abName);
		String other = abItem.other;
//			String btmName = ApProvider.getInstance().getOtherValueByType(other, BTM);
		OtherInfo otherInfo = OtherInfo.getOtherInfoByText(other);
		int refFlag = otherInfo.getRefFlag();
		String refTypeName = otherInfo.getRefTypeName();
		
		String nodeName;
		if (refFlag != -1) {
			// 参照业务类型
			if (refFlag == 0) {
				// pName: 为参照属性名加上路径
				String pName = node.getUserObject() + ".";
				String[] abNames = BtmProvider.getAbNames(refTypeName);
				for (int i = 0; i < abNames.length; i++) {
					String abName1 = abNames[i];

					AttribItem aitem = ApProvider.getAbItemByName(abName1);
					nodeName = pName + abName1;
					addNode(node, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, aitem, false)));
				}
				// 系统属性ID,NAME,DESCRIPTION
				AttribItem[] sysAbItems = BtmProvider.getInstance().getSysAttribItems();
				for (int i = 0; i < sysAbItems.length; i++) {
					AttribItem item = sysAbItems[i];
					nodeName = pName + item.name;
					addNode(node, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, item, true)));
				}
				// 参照链接类型
			} else if (refFlag == 1) {
				// pName: 为参照属性名加上路径
				String pName = node.getUserObject() + ".";
				LinkType link = null;
				try {
					link = LinkTypeProvider.getInstance().getLinkTypeByName(refTypeName);
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (Throwable e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				if (link != null) {
					String[] abNames = LinkTypeProvider.getInstance().getAbNames(link);
					for (int i = 0; i < abNames.length; i++) {
						String abName1 = abNames[i];
						AttribItem item = ApProvider.getAbItemByName(abName1);
						nodeName = pName + item.name;
						addNode(node, new VCIBaseTreeNode(pName + abName1, new AttributeNode(nodeName, item, false)));
					}
					// 系统属性ID,NAME,DESCRIPTION
					AttribItem[] sysAbItems = LinkTypeProvider.getInstance().getSysAttribItems();
					for (int i = 0; i < SystemAttribute.losysAttList().size(); i++) {
						AttribItem item = sysAbItems[i];
						nodeName = pName + item.name;
						addNode(node, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, item, true)));
					}
				}
			}
		} else {
			node.setLeaf(true);
		}

	}

	private DefaultTreeModel createLinktypeTreeModel() {
		VCIBaseTreeNode rootNode = new VCIBaseTreeNode("属性信息", "root");
		try {
			LinkType linkType = LinkTypeProvider.getInstance().getLinkTypeByName(btName);
			AttribItem[] abItems = ApProvider.getAttribItemsByNames(LinkTypeProvider.getInstance().getAbNames(linkType));
			
			//String[] sysAbItems = LinkTypeProvider.getInstance().getSysAbItems();
			VCIBaseTreeModel treeModel = new VCIBaseTreeModel(rootNode);

			for (int i = 0; i < abItems.length; i++) {
				String nodeName = abItems[i].name.toLowerCase();
				
				addNode(rootNode, new VCIBaseTreeNode(nodeName, new AttributeNode(nodeName, abItems[i], false)));
			}
			
			AttribItem[] sysAbItems = LinkTypeProvider.getInstance().getSysAttribItems();
			for (int i = 0; i < sysAbItems.length; i++) {
				AttribItem item = sysAbItems[i];

				addNode(rootNode, new VCIBaseTreeNode(item.name, new AttributeNode(item.name, item, true)));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		
		rootNode.setExpand(true);
		return new DefaultTreeModel(rootNode);
	}

	public void dragEnter(DropTargetDragEvent dtde) {

	}

	public void dragOver(DropTargetDragEvent dtde) {

		Point pt = dtde.getLocation();
		if (pt.equals(lastPoint)) {
			return;
		}
		if (ghostImage != null) {
			Graphics2D g2 = (Graphics2D) getGraphics();
			// If a drag image is not supported by the platform, then draw my
			// own drag image
			if (!DragSource.isDragImageSupported()) {
				paintImmediately(ghostRect.getBounds()); // Rub out the last
				// ghost image and cue
				// line
				// And remember where we are about to draw the new ghost image
				ghostRect.setRect(pt.x - ptOffset.x, pt.y - ptOffset.y, ghostImage.getWidth(), ghostImage.getHeight());
				g2.drawImage((ghostImage), AffineTransform.getTranslateInstance(ghostRect.getX(), ghostRect.getY()),
						null);
			}
		}
		TreePath path = getClosestPathForLocation(pt.x, pt.y);
		if (!(path == lastPath)) {
			lastPath = path;
//			hoverTimer.restart();
		}
	}

	public void dropActionChanged(DropTargetDragEvent dtde) {

	}

	public void drop(DropTargetDropEvent e) {
	}

	private void cp(File src, File dest) throws IOException {
		if (src.isDirectory()) {
			if (!dest.exists()) {
				boolean ret = dest.mkdir();
				if (ret == false)
					return;
			}
			File[] fs = src.listFiles();
			for (int i = 0; i < fs.length; i++) {
				cp(fs[i], new File(dest, fs[i].getName()));
			}
			return;
		}
		byte[] buf = new byte[1024];
		FileInputStream in = new FileInputStream(src);
		FileOutputStream out = new FileOutputStream(dest);
		int len;
		try {
			while ((len = in.read(buf)) > 0) {
				out.write(buf, 0, len);
			}
		} finally {
			in.close();
			out.close();
		}
	}

	public void dragExit(DropTargetEvent dte) {

	}
}

class AttributeNode implements java.io.Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private String _name = "";
	private AttribItem _aItem;
	private boolean _isSys = false;
	
	public AttributeNode(String name, AttribItem item, boolean isSys) {
		_name = name;
		_aItem = item;
		_isSys = isSys;
	}
	
	public String getName() {
		return _name;
	}
	
	public AttribItem getAttrItem() {
		return _aItem;
	}
	
	public boolean isSys() {
		return _isSys;
	}
}
//
//class FileNode extends DefaultMutableTreeNode {
//	private boolean explored = false;
//
//	public FileNode(File file) {
//		setUserObject(file);
//	}
//
//	public boolean getAllowsChildren() {
//		return isDirectory();
//	}
//
//	public boolean isLeaf() {
//		return !isDirectory();
//	}
//
//	public File getFile() {
//		return (File) getUserObject();
//	}
//
//	public boolean isExplored() {
//		return explored;
//	}
//
//	public boolean isDirectory() {
//		File file = getFile();
//		return file.isDirectory();
//	}
//
//	public String toString() {
//		File file = (File) getUserObject();
//		String filename = file.toString();
//		int index = filename.lastIndexOf(File.separator);
//
//		return (index != -1 && index != filename.length() - 1) ? filename.substring(index + 1) : filename;
//	}
//
//	public void explore() {
//		if (!isDirectory())
//			return;
//
//		if (!isExplored()) {
//			File file = getFile();
//			File[] children = file.listFiles();
//
//			for (int i = 0; i < children.length; ++i) {
//				if (children[i].isDirectory())
//					add(new FileNode(children[i]));
//			}
//			for (int i = 0; i < children.length; ++i) {
//				if (!children[i].isDirectory())
//					add(new FileNode(children[i]));
//			}
//			explored = true;
//		}
//	}
//
//	public void reexplore() {
//		this.removeAllChildren();
//		explored = false;
//		explore();
//	}
//}