package com.hxzkoa.udp;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import com.hxzkoa.json.tb_forward_data;

/** 数据转发对象的集合 */
@SuppressWarnings("rawtypes")
public class ForwardDatas {
	static Vector<tb_forward_data> tb_forward_datas = new Vector<>();
	static {
		// 查表
		//Iterator iterator = DatabaseManagement.get_alldate_indatabase("tb_forward_data").iterator();
		Iterator iterator = null;
		while (iterator.hasNext()) {// 迭代器存在元素
			List info = (List) iterator.next();// 将迭代器里面的元素给到info集合
			tb_forward_data forward_data = new tb_forward_data();
			forward_data.setId(Integer.parseInt((String) info.get(0)));
			forward_data.setType((String) info.get(1));
			forward_data.setIp((String) info.get(2));
			forward_data.setPort((String) info.get(3));
			forward_data.setDatatype((String) info.get(4));
			tb_forward_datas.add(forward_data);
		}
	}

	public static Vector<tb_forward_data> get_tb_forward_datas() {
		return tb_forward_datas;
	}

	public static boolean get_gas_zhuanfa() {
		boolean gas_zhuan_fa = false;// 数据转发气体不存在
		if (tb_forward_datas.size() != 0) {// 数据转发集合不为空
			for (int i = 0; i < tb_forward_datas.size(); i++) {
				tb_forward_data forward_data = tb_forward_datas.get(i);
				String type = forward_data.getType();
				String datatype = forward_data.getDatatype();
				if (type.equals("TCP") && datatype.equals("气体数据")) {
					gas_zhuan_fa = true;
				}
			}
		}
		return gas_zhuan_fa;

	}

	/** 判断某个端口,地址，协议类是否存在转发全部数据 */
	public static boolean get_all(String type, String ip, String port) {
		boolean ishave = false;

		// 如果存在了转发全部数据的选择项目
		if (forward_data_is_have(type, ip, port, "全部数据")) {
			ishave = true;
		}

		return ishave;
	}

	/** 向集合中添加一个对象 */
	public static void add_tb_forward_data(String type, String ip, String port, String datatype) {
		tb_forward_data new_forward_data = new tb_forward_data();
		new_forward_data.setIp(ip);
		new_forward_data.setPort(port);
		new_forward_data.setType(type);
		new_forward_data.setDatatype(datatype);
		tb_forward_datas.add(new_forward_data);
	}

	/** 通过ID找到某个对象 */
	public static tb_forward_data get_forward_data(String id) {
		int id0 = Integer.parseInt(id);
		tb_forward_data mou_forward_data = null;
		if (tb_forward_datas.size() != 0) {

			Iterator<tb_forward_data> it = tb_forward_datas.iterator();
			while (it.hasNext()) {
				tb_forward_data forward_data1 = it.next();
				int id1 = forward_data1.getId();
				if (id1 == id0) {
					mou_forward_data = forward_data1;
					break;
				}
			}
		}
		return mou_forward_data;
	}

	/** 删除某个对象 */
	public static void delete_forward_data(String id) {
		tb_forward_data mou_forward_data = get_forward_data(id);
		if (mou_forward_data != null) {
			tb_forward_datas.removeElement(mou_forward_data);
		}

	}

	/** 删除全部对象 */
	public static void delete_all_forward_data() {
		if (tb_forward_datas.size() != 0) {
			tb_forward_datas.removeAllElements();
		}
	}

	/** 查询某个对象是否已经存在 */
	public static boolean forward_data_is_have(String type, String ip, String port, String datatyp) {
		boolean forward_data_is_have = false;
		if (tb_forward_datas.size() != 0) {
			Iterator<tb_forward_data> it = tb_forward_datas.iterator();
			while (it.hasNext()) {
				tb_forward_data forward_data = it.next();
				String type1 = forward_data.getType();
				String ip1 = forward_data.getIp();
				String port1 = forward_data.getPort();
				String datatype1 = forward_data.getDatatype();
				if (type1.equals(type) && ip1.equals(ip) && port1.equals(port) && datatype1.equals(datatyp)) {
					forward_data_is_have = true;
					break;
				}
			}
		}

		return forward_data_is_have;

	}

	public static void xiugai(String id, String type, String ip, String port, String datatype) {
		if (get_forward_data(id) != null) {
			get_forward_data(id).setType(type);
			get_forward_data(id).setPort(port);
			get_forward_data(id).setIp(ip);
			get_forward_data(id).setDatatype(datatype);
		}
	}

	/**
	 * 获取某种转发对象的所有集合
	 * 
	 * @param type转发类型如UDP
	 * @param datype需要转发的数据
	 */
	public static Vector<tb_forward_data> get_mou_tb_forword(String type, String datatype) {
		Vector<tb_forward_data> mou_data = new Vector<>();
		if (tb_forward_datas.size() != 0) {
			Iterator<tb_forward_data> it = tb_forward_datas.iterator();
			while (it.hasNext()) {
				tb_forward_data forward_data = it.next();
				String type1 = forward_data.getType();
				String datatype1 = forward_data.getDatatype();
				if (type1.equals(type) && datatype1.equals(datatype)) {
					mou_data.add(forward_data);
				}
			}
		}

		return mou_data;
	}

	/** 获取某种类型的需要转发的数据对象集合 */
	public static Vector<tb_forward_data> get_mou_tb_forword(String type) {
		Vector<tb_forward_data> mou_data = new Vector<>();
		if (tb_forward_datas.size() != 0) {
			Iterator<tb_forward_data> it = tb_forward_datas.iterator();
			while (it.hasNext()) {
				tb_forward_data forward_data = it.next();
				String type1 = forward_data.getType();
				if (type1.equals(type)) {
					mou_data.add(forward_data);
				}
			}
		}

		return mou_data;
	}

	/** 如果存在需要TCP转发的地址和端口并且需要转发的是位置数据 */
	public static boolean have_tcp(String datatype) {
		boolean have = false;
		if (get_mou_tb_forword("TCP", datatype).size() != 0) {
			have = true;
		}
		return have;
	}

	/** 如果存在需要UDP转发的地址和端口并且需要转发的是位置数据 */
	public static boolean have_udp(String datatype) {
		boolean have = false;
		if (get_mou_tb_forword("UDP", datatype).size() != 0) {
			have = true;
		}
		return have;
	}

	/** TCP数据转发是否存在 */

}