package com.netsdk.demo.customize;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

import com.netsdk.demo.util.CaseMenu;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.NetSDKLib.*;
import com.sun.jna.Memory;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;

/**
 * MointorWall
 */
public class MonitorWallEng {

	static NetSDKLib netsdkApi 	= NetSDKLib.NETSDK_INSTANCE;
	static NetSDKLib configApi 	= NetSDKLib.CONFIG_INSTANCE;
	
	private NetSDKLib.NET_DEVICEINFO_Ex deviceinfo = new NetSDKLib.NET_DEVICEINFO_Ex();
	private LLong loginHandle = new LLong(0);   // login handle
	private fDisConnectCB  	m_DisConnectCB   = new fDisConnectCB();
	private HaveReConnect haveReConnect = new HaveReConnect(); 
	
	private Map<Integer, DecChannel> mapChannel = new HashMap<Integer, DecChannel>();
	private Map<String, ArrayList<NET_SPLIT_SOURCE>> mapSplitSource = new HashMap<String, ArrayList<NET_SPLIT_SOURCE>>();

	/*************************************************************************************
	*								General function								 	 * 
	*************************************************************************************/
	// device disconnect callback
	// call CLIENT_Init to set it, when device reconnect, sdk will call it.
	public class fDisConnectCB implements NetSDKLib.fDisConnect{
		public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser){
			System.out.printf("Device[%s] Port[%d] Disconnect!\n" , pchDVRIP , nDVRPort);
		}	
    }
		
	// device reconnect callback
	// call CLIENT_SetAutoReconnect to set it, when device reconnect, sdk will call it.
	public class HaveReConnect implements NetSDKLib.fHaveReConnect {
		public void invoke(LLong loginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
			System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
		}
	}

	/**
	 * Init Sdk and Login Device 
	 */
	public void InitTest()
	{		
		// init sdk 
		netsdkApi.CLIENT_Init(m_DisConnectCB, null);
    	
		// Set re-connection callback function after disconnection. Internal SDK auto connect again after disconnection (Optional)
		netsdkApi.CLIENT_SetAutoReconnect(haveReConnect, null); 
		
		// Set device connection timeout value and trial times, Optional
		int waitTime = 5000; // connection 5s timeout
		int tryTimes = 3;    // trial 3 times
		netsdkApi.CLIENT_SetConnectTime(waitTime, tryTimes);
		
		// Open SDK log, Optional
		NetSDKLib.LOG_SET_PRINT_INFO setLog = new NetSDKLib.LOG_SET_PRINT_INFO();
		
		File path = new File(".");			
		String logPath = path.getAbsoluteFile().getParent() + "\\sdk_log\\" + System.currentTimeMillis() + ".log";
			
		setLog.bSetFilePath = 1;
		System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
	
		setLog.bSetPrintStrategy = 1;
		setLog.nPrintStrategy = 0;
		boolean bLogopen = netsdkApi.CLIENT_LogOpen(setLog);
		if (!bLogopen) {
			System.err.println("Failed to open NetSDK log !!!");
		}
		
    	// login device
    	int nSpecCap = 0;
    	Pointer pCapParam = null;
    	IntByReference nError = new IntByReference(0);
    	loginHandle = netsdkApi.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser , 
				m_strPassword ,nSpecCap,pCapParam, deviceinfo,nError);
		
		if(loginHandle.longValue() != 0) {
    		System.out.printf("Login Device[%s] Port[%d]Success!\n" , m_strIp , m_nPort);
    	}
    	else {	
    		System.out.printf("Login Device[%s] Port[%d]Fail.Last Error[%x]\n" , m_strIp , m_nPort , netsdkApi.CLIENT_GetLastError());
    		EndTest();
    	}
	}
	
	/**
	 * Logout Device And Cleanup Sdk 
	 */
	public void EndTest()
	{
		if( loginHandle.longValue() != 0)
		{
			netsdkApi.CLIENT_Logout(loginHandle);
		}
		
		netsdkApi.CLIENT_Cleanup();
		System.exit(0);
	}
	
	/**
     * Operate Type
     * */
	public enum OPERATE_TYPE {
		SET_SPLIT_SOURCE,				// set or replace split source
		REMOVE_SPLIT_SOURCE,			// remove split source
	};
	
	/**
	 * Get Matrix Cameras Info，Using By Set Split Source
	 */
	public boolean GetMatrixCamerasInfo() {	
		
		mapSplitSource.clear();
		
		int cameraCount = 512;	

		NetSDKLib.NET_MATRIX_CAMERA_INFO[]  cameraInfo = new NetSDKLib.NET_MATRIX_CAMERA_INFO[cameraCount];
		for(int i = 0; i < cameraCount; i++) {
			cameraInfo[i] = new NetSDKLib.NET_MATRIX_CAMERA_INFO();
		}
		
		NetSDKLib.NET_IN_MATRIX_GET_CAMERAS inMatrix = new NetSDKLib.NET_IN_MATRIX_GET_CAMERAS();
		
		NetSDKLib.NET_OUT_MATRIX_GET_CAMERAS outMatrix = new NetSDKLib.NET_OUT_MATRIX_GET_CAMERAS();
		outMatrix.nMaxCameraCount = cameraCount;
		outMatrix.pstuCameras = new Memory(cameraInfo[0].size() * cameraCount);
		outMatrix.pstuCameras.clear(cameraInfo[0].size() * cameraCount);
		
		ToolKits.SetStructArrToPointerData(cameraInfo, outMatrix.pstuCameras);  // write array memory to Pointer
		if (!netsdkApi.CLIENT_MatrixGetCameras(loginHandle, inMatrix, outMatrix, 5000)) {
			System.err.println("MatrixGetCameras Failed." + ToolKits.getErrorCode());
			return false;
		}

		ToolKits.GetPointerDataToStructArr(outMatrix.pstuCameras, cameraInfo);  // read Pointer's data to array
		
		for (int j = 0; j < outMatrix.nRetCameraCount; j++) {
			if(cameraInfo[j].bRemoteDevice == 0) {   // filter remote device
				continue;
			}
			
			String ip = new String(cameraInfo[j].stuRemoteDevice.szIp).trim();
			ArrayList<NET_SPLIT_SOURCE> lstSplitSource = mapSplitSource.get(ip);
			if (lstSplitSource != null) {
				lstSplitSource.add(convertMatrixCamera(cameraInfo[j]));
			}else {
				lstSplitSource = new ArrayList<NET_SPLIT_SOURCE>();
				lstSplitSource.add(convertMatrixCamera(cameraInfo[j]));
				mapSplitSource.put(ip, lstSplitSource);
			}
		}
		
		return true;
	}
	
	
	/**
	 * Convert Matrix Camera Info to Split Source
	 */
	public NET_SPLIT_SOURCE convertMatrixCamera(NET_MATRIX_CAMERA_INFO cameraInfo) {
		NET_SPLIT_SOURCE stSplitSource = new NET_SPLIT_SOURCE();
				
		stSplitSource.bEnable = 1; // enable
		
		System.arraycopy(cameraInfo.stuRemoteDevice.szIp, 0, stSplitSource.szIp, 0, cameraInfo.stuRemoteDevice.szIp.length); // ip
		
		stSplitSource.nPort = cameraInfo.stuRemoteDevice.nPort; // port
		
		System.arraycopy(cameraInfo.stuRemoteDevice.szUserEx, 0, stSplitSource.szUserEx, 0, cameraInfo.stuRemoteDevice.szUserEx.length); // user

		System.arraycopy(cameraInfo.stuRemoteDevice.szPwdEx, 0, stSplitSource.szPwdEx, 0, cameraInfo.stuRemoteDevice.szPwdEx.length); // password
								
		stSplitSource.nVideoChannel = cameraInfo.stuRemoteDevice.nVideoInputChannels;  // video input channels
		
		stSplitSource.nChannelID = cameraInfo.nUniqueChannel;  // channel id

		stSplitSource.nStreamType = cameraInfo.emStreamType - 1; // stream type
		
		stSplitSource.byConnType = 0; // connect type -1: auto, 0: TCP, 1: UDP, 2: multicast
		
		stSplitSource.dwRtspPort = cameraInfo.stuRemoteDevice.nRtspPort; // Rtsp port
				
		stSplitSource.emProtocol = NET_DEVICE_PROTOCOL.NET_PROTOCOL_PRIVATE2;  // Protocol type
		
		return stSplitSource;
	}
	
	/**
	 * Video Out Channel Class
	 * using as data, all fields are public  
	 */
	class DecChannel
	{
		public int						nChannelID;					// channel id
		public int						nCardID;					// card id
		public int						nCardSlot;					// card slot
		public boolean					bSpliceScreen;				// splice screem or not (composite channel's part)
		public boolean					bComposite;					// composite channel or not
		public String					monitorWallName;			// composite name
		
		public DecChannel(int nChannelID, int nCardID, int nCardSlot) {
			this.nChannelID = nChannelID;
			this.nCardID = nCardID;
			this.nCardSlot = nCardSlot;
			this.bSpliceScreen = false;
			this.bComposite = false;
			this.monitorWallName = null;
		}
	}
	
	/**
	 * Get Physical Channel Info
	 */
	public boolean GetPhysicalChannelInfo() {
		
 		NET_MATRIX_CARD_LIST pstuCardList = new NET_MATRIX_CARD_LIST();
 		if (! netsdkApi.CLIENT_QueryMatrixCardInfo(loginHandle, pstuCardList, 5000)) {
 			System.err.println("GetPhysicalChannelInfo failed!" + ToolKits.getErrorCode());
 			return false;
 		}
 		
 		NET_MATRIX_CARD stuCard;
		for (int i = 0; i < pstuCardList.nCount; i++) {
			stuCard = pstuCardList.stuCards[i];
			
			if(stuCard.bEnable == 0) {
				continue;
			}
			
			if ((stuCard.dwCardType & NetSDKLib.NET_MATRIX_CARD_OUTPUT) 
					== NetSDKLib.NET_MATRIX_CARD_OUTPUT && stuCard.nVideoOutChn > 0) { // output card
				for (int j = stuCard.nVideoOutChnMin; j <= stuCard.nVideoOutChnMax; ++j){
					DecChannel decChannel = new DecChannel(j, i, j - stuCard.nVideoOutChnMin); 
					mapChannel.put(j, decChannel);
				}
			}else if ((stuCard.dwCardType & NetSDKLib.NET_MATRIX_CARD_DECODE) 
					== NetSDKLib.NET_MATRIX_CARD_DECODE && stuCard.nVideoDecChn > 0) { // decode card
				
				for (int j = stuCard.nVideoDecChnMin; j <= stuCard.nVideoDecChnMax; ++j) {
					DecChannel decChannel = new DecChannel(j, i, j - stuCard.nVideoDecChnMin);
					mapChannel.put(j, decChannel);
				}
			}
		}
		
		return true;
	}
	
	/**
	 * Get Composite Channel Info
	 */
	public boolean GetCompositeChannelInfo() {

		int nComposite = 256; // max splicing screen number
		NET_COMPOSITE_CHANNEL[] compositeChn = new NET_COMPOSITE_CHANNEL[nComposite];
		for(int i = 0; i <nComposite; i++) {
			compositeChn[i] = new NET_COMPOSITE_CHANNEL();
		}
		
		int memorySize = nComposite * compositeChn[0].size();
		Memory memory = new Memory(memorySize);
		memory.clear(memorySize);
		
		ToolKits.SetStructArrToPointerData(compositeChn, memory);
		
		IntByReference intRetLen = new IntByReference();
		if (!netsdkApi.CLIENT_QueryDevState(loginHandle, NetSDKLib.NET_DEVSTATE_COMPOSITE_CHN, 
				memory, memorySize, intRetLen, 3000)) {
			System.err.println("GetCompositeChannelInfo failed!" + ToolKits.getErrorCode());
 			return false;
		}
			
		int nSpliceCount = intRetLen.getValue() / compositeChn[0].size();   // splicing screen number

		if(nSpliceCount > nComposite) {
			nSpliceCount = nComposite;
		}
		
		ToolKits.GetPointerDataToStructArr(memory, compositeChn);

		for (int i = 0; i < nSpliceCount; ++i)
		{	
			if (compositeChn[i].szCompositeID[0] == '\0') {
				continue;
			}
			
			if (!mapChannel.containsKey(compositeChn[i].nVirtualChannel)) { // composite channel
				DecChannel decChannel = new DecChannel(compositeChn[i].nVirtualChannel, -1, -1); 
				decChannel.bComposite = true;
				decChannel.monitorWallName = new String(compositeChn[i].szMonitorWallName).trim();
				mapChannel.put(compositeChn[i].nVirtualChannel, decChannel);
			}else {
				System.err.println("get composite channel " + compositeChn[i].nVirtualChannel+ " again.");
			}
		}
		
		return true;
	}
	
	/**
	 * Get Monitor Wall Configure
	 */
	public boolean GetMonitorWallConfig() {
		
		int nMaxMonitorWall = 10;   // max monitor wall count (the struct is too large for you to create more at a time)
				
		AV_CFG_MonitorWall[] monitorWall = new AV_CFG_MonitorWall[nMaxMonitorWall];
		for (int i = 0; i < nMaxMonitorWall; i++) {
			monitorWall[i] = new AV_CFG_MonitorWall();
		}
		
		int nRetCount = ToolKits.GetDevConfig(loginHandle, -1, NetSDKLib.CFG_CMD_MONITORWALL, monitorWall);
		if (nRetCount == -1) {
			System.err.println("GetMonitorWallConfig failed!" + ToolKits.getErrorCode());
 			return false;
		}
		
		if (nRetCount > nMaxMonitorWall) {
			nRetCount = nMaxMonitorWall;
		}
		
		for(int i = 0; i < nRetCount; i++) {
			for(int j = 0; j < monitorWall[i].nBlockCount; j++) {
				for(int k = 0; k < monitorWall[i].stuBlocks[j].nTVCount; k++) {			
					DecChannel devChannel = mapChannel.get(monitorWall[i].stuBlocks[j].stuTVs[k].nChannelID);
					if (devChannel != null){
						devChannel.bSpliceScreen = true; 
					}else { // the normal code will never to here
						System.err.println("Had config channel " + monitorWall[i].stuBlocks[j].stuTVs[k].nChannelID + ", but can't find it in channel map.");
					}
				}
			}
		}
		
		return true;
	}
	
	/**
	 * Get Video Out Channel Info
	 */
	public void  GetVideoOutChannelInfo() {
		
		mapSplitSource.clear();
		
		System.out.println("Get Physical Channel Info...");
		GetPhysicalChannelInfo();
		System.out.println("Get Composite Channel Info...");
		GetCompositeChannelInfo();
		System.out.println("Get Monitor Wall Config...");
		GetMonitorWallConfig();
	}
	
	/**
	 * Get Out Channel's Window Count
	 */
	public int GetWhnCount(int nOutChannel) {
		
		int nWindow = 0;

		NET_SPLIT_MODE_INFO splitMode = new NET_SPLIT_MODE_INFO();

		if (!netsdkApi.CLIENT_GetSplitMode(loginHandle, nOutChannel, splitMode, 3000)) {
			System.err.println("GetWhnCount [GetSplitMode] Filed" + ToolKits.getErrorCode());
			return nWindow;
		}
		
		if(splitMode.emSplitMode == NET_SPLIT_MODE.NET_SPLIT_FREE) { // free open window mode

			NET_IN_SPLIT_GET_WINDOWS stuInGetWhn = new NET_IN_SPLIT_GET_WINDOWS();
			stuInGetWhn.nChannel = nOutChannel;

			NET_OUT_SPLIT_GET_WINDOWS stuOutGetWhn = new NET_OUT_SPLIT_GET_WINDOWS();
			
			if (netsdkApi.CLIENT_GetSplitWindowsInfo(loginHandle, stuInGetWhn, stuOutGetWhn, 3000)) {
				
				nWindow = stuOutGetWhn.stuWindows.nWndsCount;

				/*for (int i = 0; i < stuOutGetWhn.stuWindows.nRetWndsCountEx; ++i) {
					DH_RECT stuRect =stuOutGetWhn.stuWindows.stuWnds[i].stuRect;
					if ((stuRect.left.longValue() == 0) && (stuRect.top.longValue() == 0) 
							&& (stuRect.right.longValue() == 0) && (stuRect.bottom.longValue() == 0)) { 
						// this window not open
					}
				}*/
			}
		} else {
			nWindow = splitMode.emSplitMode;
		}
		
		return nWindow;
	}
	
	
	/**
	 * Open Split Window
	 */
	public void OpenSplitWindow() {
			
		Scanner scanner = new Scanner(System.in);
							
		ShowVideoOutChannelInfo();

		System.out.print("Input Out Channel");
		if (mapChannel.isEmpty()) {
			System.out.print(": ");
		}else {
			System.out.print(" From Matrix Channel List: ");
		}
		int nChannel = scanner.nextInt();
		
		OpenSplitWindow(nChannel, scanner);
	}
	
	public int OpenSplitWindow(int nChannel, Scanner scanner) {
							
		NET_IN_SPLIT_OPEN_WINDOW stIn = new NET_IN_SPLIT_OPEN_WINDOW();
		
		stIn.nChannel = nChannel;
		
		System.out.print("Input Windon Position, 0~8192 (left top right bottom), eg 0 0 8192 8192: ");
		// Windon Position, 0~8192
		stIn.stuRect.left = new NativeLong(scanner.nextInt());
		stIn.stuRect.top = new NativeLong(scanner.nextInt());
		stIn.stuRect.right = new NativeLong(scanner.nextInt());
		stIn.stuRect.bottom = new NativeLong(scanner.nextInt());
					
		NET_OUT_SPLIT_OPEN_WINDOW stOut = new NET_OUT_SPLIT_OPEN_WINDOW();
		
		if(netsdkApi.CLIENT_OpenSplitWindow(loginHandle, stIn, stOut, 3000)) {
			System.out.println("Out Channel " + stIn.nChannel + " Open Split Window Success！ Window ID:" + stOut.nWindowID);
		} else {
			System.err.println("Out Channel " + stIn.nChannel + " Open Split Window Failed！ " + ToolKits.getErrorCode());
			return -1;
		}
		
		return stOut.nWindowID;
	}
	
	/**
	 * Close Split Window
	 */
	public void CloseSplitWindow() {
		
		Scanner scanner = new Scanner(System.in);
		
		NET_IN_SPLIT_CLOSE_WINDOW stIn = new NET_IN_SPLIT_CLOSE_WINDOW();

		ShowVideoOutChannelInfo();
		
		System.out.print("Input Out Channel");
		if (mapChannel.isEmpty()) {
			System.out.print(": ");
		}else {
			System.out.print(" From Matrix Channel List: ");
		}
		stIn.nChannel = scanner.nextInt();
		
		int nWindowCount = GetWhnCount(stIn.nChannel); // you should know window status first
		if (nWindowCount !=0) {
			System.out.print("Input Window Number Range[0~" + nWindowCount + "): ");
			stIn.nWindowID = scanner.nextInt();
		}else {
			System.out.print("Input Window Number(Start 0): ");
			stIn.nWindowID = scanner.nextInt();
		}
		
		stIn.pszCompositeID = "";				 // Composite ID

		NET_OUT_SPLIT_CLOSE_WINDOW stOut = new NET_OUT_SPLIT_CLOSE_WINDOW();
		
		if(netsdkApi.CLIENT_CloseSplitWindow(loginHandle, stIn, stOut, 3000)) {
			System.out.println("Out Channel " + stIn.nChannel + " Window " + stIn.nWindowID + " Close Split Window Success！");
		} else {
			System.err.println("Out Channel " + stIn.nChannel + " Window " + stIn.nWindowID + " Close Split Window Failed！ " + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * Show Matrix Camera Info
	 */
	public void ShowMatrixCamerasInfo() {
		if (GetMatrixCamerasInfo()) {
			System.out.println("---------------------------------------------------------");
			for (String ip : mapSplitSource.keySet()) {
				System.out.print(ip + " ");
			}
			System.out.println();
			System.out.println("---------------------------------------------------------");
		}
	}
	
	/**
	 * Show Video Out Channel Info
	 */
	public void ShowVideoOutChannelInfo() {
		
		if (mapChannel.isEmpty()) {
			GetVideoOutChannelInfo();
		}
		
		if (mapChannel.isEmpty()) {
			return;
		}
		
		System.out.println("Matrix Channel List: ");
		for (DecChannel decChannel : mapChannel.values()) {
			if (!decChannel.bComposite) {
				if (!decChannel.bSpliceScreen) {
					System.out.print(decChannel.nChannelID + " ");
				}else {
					System.out.print(decChannel.nChannelID + "(TV) ");
				}
			}else {
				System.out.print(decChannel.nChannelID + "(" + decChannel.monitorWallName + ") ");
			}
		}
		System.out.println();
	}
	
	/**
	 * Set Split Source
	 */
	public void SetSplitSource() {
		
		Scanner scanner = new Scanner(System.in);
		NetSDKLib.NET_SPLIT_SOURCE splitSource = new NetSDKLib.NET_SPLIT_SOURCE();
		
		// Step 1: Select Video Out Channel
		ShowVideoOutChannelInfo(); 
		System.out.print("Input Out Channel");
		if (mapChannel.isEmpty()) {
			System.out.print(": ");
		}else {
			System.out.print(" From Matrix Channel List: ");
		}
		int nOutChannel = scanner.nextInt();
					
		// Step 2: Select Window Number
		int nWindow = 0;
		int nWindowCount = GetWhnCount(nOutChannel);
		if (nWindowCount !=0) {
			System.out.print("Input Window Number Range[0~" + nWindowCount + "): ");
			nWindow = scanner.nextInt();
		}else {
			System.out.println("No Windows, Need Open Split Window.");
			nWindow = OpenSplitWindow(nOutChannel, scanner);
			if (nWindow == -1) {
				return;
			}
		}
			
		// Step 3: Select Matrix Cameras
		GetMatrixCamerasInfo(); // TODO if you want input device info by yourself just don't call this function
		if (mapSplitSource.isEmpty()) {
			
			splitSource.bEnable = 1;  // enable
			
			System.out.print("Input Device IP: ");
			String ip = scanner.next();
			System.arraycopy(ip.getBytes(), 0, splitSource.szIp, 0, ip.getBytes().length);
			
			System.out.print("Input Device Port: ");
			splitSource.nPort = scanner.nextInt();
			
			System.out.print("Input Device User: ");
			String user = scanner.next();
			System.arraycopy(user.getBytes(), 0, splitSource.szUserEx, 0, user.getBytes().length);
			
			System.out.print("Input Device Password: ");
			String pwd = scanner.next();
			System.arraycopy(pwd.getBytes(), 0, splitSource.szPwdEx, 0, pwd.getBytes().length);
			
			System.out.print("Input Device Channel(Start 0): ");
			splitSource.nChannelID = scanner.nextInt();

			System.out.print("Input Device Video Channel Count: ");
			splitSource.nVideoChannel = scanner.nextInt();
			
			splitSource.nStreamType = 0;

			splitSource.byConnType = 0;

			splitSource.emProtocol = NET_DEVICE_PROTOCOL.NET_PROTOCOL_PRIVATE2;  // default
		
		}else {
			
			System.out.println("Ip List: ");
			for (String ip : mapSplitSource.keySet()) {
				System.out.print(ip + " ");
			}
			System.out.println();
			
			System.out.print("Input Ip From Ip List: ");
			String ip = scanner.next();
			
			ArrayList<NET_SPLIT_SOURCE> lstSplitSource = mapSplitSource.get(ip);
			if (lstSplitSource == null) {
				System.out.println("IP Incorrect...");
				return;
			}
			
			if (lstSplitSource.size() > 1) {
				System.out.println("Channel List: ");
				for (NET_SPLIT_SOURCE itemSource : lstSplitSource) {
					System.out.print(itemSource.nChannelID + " ");
				}
				System.out.println();
				System.out.print("Input Channel ID From Channel List: ");
				int nChannelID = scanner.nextInt();
				
				for (NET_SPLIT_SOURCE itemSource : lstSplitSource) {
					if (itemSource.nChannelID == nChannelID) {
						splitSource = itemSource;
						break;
					}
				}
				
				if (splitSource.bEnable != 1) {
					System.out.println("Channel ID Incorrect...");
				}
			}else {
				splitSource = lstSplitSource.get(0);
			}
			
			if (splitSource.szUserEx[0] == '\0') {
				System.out.print("Input Device User: ");
				String user = scanner.next();
				System.arraycopy(user.getBytes(), 0, splitSource.szUserEx, 0, user.getBytes().length);
			}
			
			if (splitSource.szPwdEx[0] == '\0') {
				System.out.print("Input Device Password: ");
				String pwd = scanner.next();
				System.arraycopy(pwd.getBytes(), 0, splitSource.szPwdEx, 0, pwd.getBytes().length);
			}
		}
		
		// Step 4: Set Split Source
		int nSrcCount = 1; // Split Source number (Fixed to 1)
		if (netsdkApi.CLIENT_SetSplitSource(loginHandle, nOutChannel, nWindow, splitSource, nSrcCount, 3000)) {
			System.out.println("Set Or Replace Split Source Success!");
		} else {
			System.err.println("Set Or Replace Split Source Failed!" + ToolKits.getErrorCode());
		}
	}
	
	
	public void RemoveSplitSource() {
		
		Scanner scanner = new Scanner(System.in);
		
		// Step 1: Input Video Out Channel
		ShowVideoOutChannelInfo(); 
		System.out.print("Input Out Channel");
		if (mapChannel.isEmpty()) {
			System.out.print(": ");
		}else {
			System.out.print(" From Matrix Channel List: ");
		}
		int nOutChannel = scanner.nextInt();

		// Step 2: Select Window Number
		int nWindow = 0;
		int nWindowCount = GetWhnCount(nOutChannel);
		if (nWindowCount !=0) {
			System.out.print("Input Window Number Range[0~" + nWindowCount + "): ");
			nWindow = scanner.nextInt();
		}else {
			System.out.print("Input Window Number(Start 0): ");
			nWindow = scanner.nextInt();
		}
		
		// Step 3: Set Split Source
		int nSrcCount = 1; // Split Source number (Fixed to 1)
		NetSDKLib.NET_SPLIT_SOURCE splitSource = new NetSDKLib.NET_SPLIT_SOURCE();

		if (netsdkApi.CLIENT_SetSplitSource(loginHandle, nOutChannel, nWindow, splitSource, nSrcCount, 3000)) {
			System.out.println("Remove Split Source Success!");
		} else {
			System.err.println("Remove Split Source Failed!" + ToolKits.getErrorCode());
		}
	}
	
	////////////////////////////////////////////////////////////////
	String m_strIp 			= "171.2.3.116";  
	int    m_nPort 			= 37777;
	String m_strUser 		= "admin";
	String m_strPassword 	= "admin123";
	////////////////////////////////////////////////////////////////
	
	public void RunTest()
	{
		System.out.println("Run Test");		
		CaseMenu menu = new CaseMenu();
		menu.addItem(new CaseMenu.Item(this , "Show Matrix Cameras Info" , "ShowMatrixCamerasInfo"));
		menu.addItem(new CaseMenu.Item(this , "Show Video Out Channel Info" , "ShowVideoOutChannelInfo"));
		menu.addItem(new CaseMenu.Item(this , "Set Or Replace Split Source" , "SetSplitSource"));
		menu.addItem(new CaseMenu.Item(this , "Remove Split Source" , "RemoveSplitSource"));
		menu.addItem(new CaseMenu.Item(this , "Open Split Window" , "OpenSplitWindow"));
		menu.addItem(new CaseMenu.Item(this , "Close Split Window" , "CloseSplitWindow"));
		
		menu.run(); 
	}	

	public static void main(String[]args)
	{		
		MonitorWallEng demo = new MonitorWallEng();
		demo.InitTest();
		demo.RunTest();
		demo.EndTest();
	}

}