package com.nis.web.controller.dashboard;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import com.nis.util.CodeDicUtils;
import com.nis.util.Constants;
import com.nis.util.StringUtil;
import com.nis.util.httpclient.HttpClientUtil;
import com.nis.web.controller.BaseController;
import com.nis.web.dao.dashboard.codedic.CodeResult;
@SuppressWarnings("rawtypes")
@Controller
@RequestMapping(value = "${adminPath}/dashboard")
public class DashboardController extends BaseController{
	
	
	/**
	 * 跳转到图表界面
	 * @return
	 */
	@RequestMapping(value="logChart")
	public String logChart(){
		
		return "/dashboard/dashBoardIndex";
	}

	/**
	 * 活跃IP TOP10
	 */
	@RequestMapping(value="ipActive")
	@ResponseBody
	public List ipActive(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List list = new ArrayList();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_IPACTIVE);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (ArrayList) fromJsonList.get("data");
			logger.info("活跃IP数据"+fromJsonList);
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("活跃IP错误"+e);
		}
		return list;
	}
	/**
	 * 协议统计
	 */
	@RequestMapping(value="protocol")
	@ResponseBody
	public List protocolChart(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_PROTOCOL);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList = CodeDicUtils.getCodeList("protocolCode");
			//将数字替换为标签文字
			if(list!=null&&!list.isEmpty()){
			for (Map map : list) {
				Double value1 = Double.parseDouble(map.get("protoType").toString());
				for (CodeResult code : codeList) {
					Double value2 = Double.valueOf(code.getCode());
					if(value1.equals(value2)){
						map.put("protoType", code.getItem());
						break;
					}
				}
				resultList.add(map);
			}
			logger.info("协议统计"+fromJsonList);
			return resultList;
			}
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("协议统计错误"+e);
		}
		return resultList;
	}
	/**
	 * app流量分析
	 */
	@RequestMapping(value="app")
	@ResponseBody
	public List appChart(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_APP);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList = CodeDicUtils.getCodeList("appCode");
			//将数字替换为标签文字
			if(list!=null&&!list.isEmpty()){
			for (Map map : list) {
				Double value1 = Double.parseDouble(map.get("appType").toString());
				for (CodeResult code : codeList) {
					Double value2 = Double.valueOf(code.getCode());
					if(value1.equals(value2)){
						map.put("appType", code.getItem());
						break;
					}
				}
				resultList.add(map);
			}
			logger.info("app流量分析"+fromJsonList);
			return resultList;
			}
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("app流量分析错误"+e);
		}
		return resultList;
	}
	/**
	 * 终端用户-操作系统列表
	 */
	@RequestMapping(value="osList")
	@ResponseBody
	public List osList(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_OSLIST);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList = CodeDicUtils.getCodeList("osCode");
			//将数字替换为标签文字
			if(list!=null&&!list.isEmpty()){
			for (Map map : list) {
				Double value1 = Double.parseDouble(map.get("osType").toString());
				for (CodeResult code : codeList) {
					Double value2 = Double.valueOf(code.getCode());
					if(value1.equals(value2)){
						map.put("osType", code.getItem());
						break;
					}
				}
				resultList.add(map);
			}
			logger.info("终端用户-获取操作系统列表"+fromJsonList);
			return resultList;
			}
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("终端用户-获取操作系统列表错误"+e);
		}
		return resultList;
	}
	/**
	 * 终端用户-指定操作系统下浏览器分类流量统计
	 */
	@RequestMapping(value="browserChart")
	@ResponseBody
	public List browserChart(@RequestParam("osType") String osType){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		//标签集合
		List<CodeResult> codeList1 = CodeDicUtils.getCodeList("osCode");
		//将标签文字转为数字
		Integer os=null;
		for (CodeResult codeResult : codeList1) {
			if(osType.equalsIgnoreCase(codeResult.getItem())){
				os=Integer.parseInt(codeResult.getCode());
				break;
			}
		}
		if(os==null){
			os=Integer.parseInt(osType);//处理为匹配项编码
		}
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_BROWSER_CHART+"?osType="+os);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList2 = CodeDicUtils.getCodeList("browserCode");
			//将数字替换为标签文字
			if(null!=list&&!list.isEmpty()){
				for (Map map : list) {
					Double value1 = Double.parseDouble(map.get("bsType").toString());
					for (CodeResult code : codeList2) {
						Double value2 = Double.valueOf(code.getCode());
						if(value1.equals(value2)){
							map.put("bsType", code.getItem());
							break;
						}
					}
					resultList.add(map);
				}
			}
			logger.info("终端用户-获取操作系统下浏览器类型"+fromJsonList);
			return resultList;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("终端用户-获取操作系统下浏览器类型错误"+e);
		}
		return resultList;
	}
	/**
	 * 终端用户-浏览器列表
	 */
	@RequestMapping(value="bsList")
	@ResponseBody
	public List bsList(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_BSLISTL);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList = CodeDicUtils.getCodeList("browserCode");
			//将数字替换为标签文字
			if(list!=null&&!list.isEmpty()){
			for (Map map : list) {
				Double value1 = Double.parseDouble(map.get("bsType").toString());
				for (CodeResult code : codeList) {
					Double value2 = Double.valueOf(code.getCode());
					if(value1.equals(value2)){
						map.put("bsType", code.getItem());
						break;
					}
				}
				resultList.add(map);
				}
			}
			logger.info("终端用户-获取浏览器列表"+fromJsonList);
			return resultList;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("终端用户-获取浏览器列表错误"+e);
		}
		return resultList;
	}
	/**
	 * 终端用户-指定操作系统下浏览器分类流量统计
	 */
	@RequestMapping(value="systemChart")
	@ResponseBody
	public List systemChart(@RequestParam("bsType") String bsType){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		//标签集合
		List<CodeResult> codeList1 = CodeDicUtils.getCodeList("browserCode");
		//将标签文字转为数字
		Integer bs=null;
		for (CodeResult codeResult : codeList1) {
			if(bsType.equalsIgnoreCase(codeResult.getItem())){
				bs=Integer.parseInt(codeResult.getCode());
				break;
			}
		}
		if(bs==null){
			bs=Integer.parseInt(bsType);//处理为匹配项编码
		}
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_SYSTEM_CHART+"bsType="+bs);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList2 = CodeDicUtils.getCodeList("osCode");
			//将数字替换为标签文字
			if(null!=list&&!list.isEmpty()){
				for (Map map : list) {
					Double value1 = Double.parseDouble(map.get("osType").toString());
					for (CodeResult code : codeList2) {
						Double value2 = Double.valueOf(code.getCode());
						if(value1.equals(value2)){
							map.put("osType", code.getItem());
							break;
						}
					}
					resultList.add(map);
				}
			}
			logger.info("终端用户-获取浏览器下操作系统类型"+fromJsonList);
			return resultList;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("终端用户-获取浏览器下操作系统类型错误"+e);
		}
		return resultList;
	}
	/**
	 * http网站统计
	 */
	@RequestMapping(value="websiteList")
	@ResponseBody
	public List websiteList(){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_WEBSITELIST);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList = CodeDicUtils.getCodeList("webCode");
			//将数字替换为标签文字
			if(list!=null&&!list.isEmpty()){
				for (Map map : list) {
					Double value1 = Double.parseDouble(map.get("webId").toString());
					for (CodeResult code : codeList) {
						Double value2 = Double.valueOf(code.getCode());
						if(value1.equals(value2)){
							map.put("webId", code.getItem());
							break;
						}
					}
					resultList.add(map);
				}
			}
			logger.info("http网站流量分析数据："+fromJsonList);
			return resultList;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("http网站流量分析数据错误："+e);
		}
		return resultList;
	}
	/**
	 * http网站-某个网站的分类统计
	 */
	@RequestMapping(value="webTypeChart")
	@ResponseBody
	public List webTypeChart(@RequestParam("webId") String webId){
		Map<String, Object> fromJsonList = new HashMap<String, Object>();
		List<Map> list = new ArrayList<Map>();
		List<Map> resultList = new ArrayList<Map>();
		//标签集合
		List<CodeResult> codeList1 = CodeDicUtils.getCodeList("webCode");
		//将标签文字转为数字
		Integer web=null;
		for (CodeResult codeResult : codeList1) {
			if(webId.equalsIgnoreCase(codeResult.getItem())){
				web=Integer.parseInt(codeResult.getCode());
				break;
			}
		}
		if(web==null){
			web=Integer.parseInt(webId);//处理为匹配项编码
		}
		try {
			String string = HttpClientUtil.get(Constants.DASHBOARD_URL+Constants.TRAFFIC_WEBTYPECHART+"webId="+web);
			Gson gson = new GsonBuilder().create();
			fromJsonList = gson.fromJson(string, new TypeToken<Map>(){}.getType());
			list = (List<Map>) fromJsonList.get("data");
			//标签集合
			List<CodeResult> codeList2 = CodeDicUtils.getCodeList("webCode");//网站分类字典-未定义？
			//将数字替换为标签文字
			if(null!=list&&!list.isEmpty()){
				for (Map map : list) {
					Double value1 = Double.parseDouble(map.get("webType").toString());
					for (CodeResult code : codeList2) {
						Double value2 = Double.valueOf(code.getCode());
						if(value1.equals(value2)){
							map.put("webType", code.getItem());
							break;
						}
					}
					resultList.add(map);
				}
			}
			logger.info("http某个网站分类流量统计"+fromJsonList);
			return resultList;
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("http某个网站分类流量统计错误"+e);
		}
		return resultList;
	}
}