package com.nko.utils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import com.nko.bean.Keyword;
import com.nko.bean.Parameter;

public class DisposeFile {

	public static final String PREFIX = "index_";
	static final String PRIPATH = "F:\\code workspace\\Wechat\\WebRoot\\Files\\";
//	static final String PRIPATH = "C:\\Wechat\\WebRoot\\Files\\";

	/**
	 * 暂定方法 TODO: update
	 * 读取消息储存的json文件中保存的消息
	 * @param fileName
	 * @return
	 */
	public static Object readFile(String fileName) {
		System.out.println(fileName);
		// "message.json"
		File file = new File(PRIPATH + fileName + ".json");
		BufferedReader reader = null;
		String lastStr = "";
		try {
			reader = new BufferedReader(new FileReader(file));
			String tempStr = null;
			int line = 1;

			while ((tempStr = reader.readLine()) != null) {		// 一次读入一行，直到读入null为文件结束
				lastStr += tempStr;
				lastStr += "\n";	//TODO: update
				line++;
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

//		System.out.println(lastStr);

		String[] jsonArr = lastStr.split("\n");
		List list = null;

		switch(fileName) {
			case "message":
			case "others":
				list = new ArrayList<Parameter>();
				for(String str : jsonArr) {
					String[] items = str.split("}]");
					for(String s : items) {
//						System.out.println(s);
						String[] subItems = s.split("\",");
						list.add(getParam(subItems));
					}
				}
				break;
			case "keywordAutoReply":
				for(String str : jsonArr) {
					String[] items = str.split("}]");
					for(String s : items) {
//						System.out.println(s);
						String[] subItems = s.split("\",");
						list.add(getKeyword(subItems));
					}
				}
				break;
		}

		System.out.println(lastStr);
		// 获得json文件的内容
		JSONObject obj = JSONObject.fromObject(lastStr);
//		 格式化成 json对象
//		Parameter param = new Parameter();
////		param.setContent(jo.getString("content"));
//		System.out.println(param.getContent());
		return list;
	}

	/**
	 * 暂定读取json文件方法中提出的赋值到List<Parameter>对象的方法
	 * @param jsonArr
	 * @return
	 */
	static Parameter getParam(String[] strs) {
		Parameter param = new Parameter();
		for(String str : strs) {
			System.out.println(str);
			String key = str.substring(str.indexOf("\"") + 1, str.indexOf("\":"));
//			System.out.println("==key" + key);
			String value = str.substring(str.indexOf(":\"") + 2, str.length());
//			System.out.println(value);

			if(! key.equals("item")) {
				param = setParams(key, value);
			} else {
				System.out.println(key);
				List<Parameter> item = new ArrayList<Parameter>();
				for (String subTmp : key.split(",")) {
					item.add(setParams(key, value));
					param.setItem(item);
				}
			}
		}
		return param;
	}

	/**
	 * 暂定读取json文件方法中提出的赋值到List<Keyword>对象的方法
	 * @param jsonArr
	 * @return
	 */
	static Keyword getKeyword(String[] strs) {
		Keyword keyword = new Keyword();
		for(String str : strs) {
			System.out.println(str);
			String key = str.substring(str.indexOf("\"") + 1, str.indexOf("\":"));
			String value = str.substring(str.indexOf(":\"") + 2, str.length());

			if(key.equals("key")) {
				keyword.setKey(value);
			} else {
				keyword.setParam(getParam(str.split("]")));
			}
		}
		return keyword;
	}

	/**
	 * TODO: update
	 * 暂定读取json文件方法中提出的赋值到Parameter对象的方法
	 * @param str
	 * @return
	 */
	private static Parameter setParams(String key, String value) {
		Parameter param = new Parameter();

		switch(key) {
			case "url":				param.setUrl(value);			break;
			case "time":			param.setTime(value);			break;
			case "event":			param.setEvent(value);			break;
			case "title":			param.setTitle(value);			break;
			case "picUrl":			param.setPicUrl(value);			break;
			case "content":			param.setContent(value);		break;
			case "msgType":			param.setMsgType(value);		break;
			case "category":		param.setCategory(value);		break;
			case "eventKey":		param.setEventKey(value);		break;
			case "funcFlag":		param.setFuncFlag(value);		break;
			case "toUserName":		param.setToUserName(value);		break;
			case "description":		param.setDescription(value);	break;
			case "fromUserName":	param.setFromUserName(value);	break;
		}
		return param;
	}

	/**
	 * 读取配置文件
	 */
	public static void readConfig() {
		Properties pro = new Properties();
		String filePath = DisposeFile.class.getResource("/config.properties").getPath();
		FileInputStream fin;
		try {
			fin = new FileInputStream(filePath);
			pro.load(fin);
			fin.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获得指定文件的byte数组
	 * @param pathname
	 * @return
	 * @throws IOException
	 */
	public static byte[] file2Bytes(String pathname)
			throws IOException {
		byte[] buffer = null;
		if (pathname == null || pathname.equals("") || pathname == "")
			return null;

		File file = new File(pathname);
		if (file.exists()) {
			try {
				buffer = file2Bytes(file);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return buffer;
	}

	/**
	 * 获得指定文件的byte数组
	 * 
	 * @param file
	 * @return
	 * @throws IOException
	 */
	public static byte[] file2Bytes(File file)
			throws IOException {
		byte[] buffer = null;
		try {

			FileInputStream fis = new FileInputStream(file);
			ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
			byte[] b = new byte[1000];
			int n;
			while ((n = fis.read(b)) != -1) {
				bos.write(b, 0, n);
			}
			fis.close();
			bos.close();
			buffer = bos.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		return buffer;
	}

	/**
	 * 生成文件并写入内容
	 * 
	 * @param file_name
	 * @param bytes
	 */
	public static void WriteFile(String file_name, byte[] bytes) {
		if (bytes.length < 0)	return;
		FileWriter fw = null;
		PrintWriter pw = null;
		File file = new File(file_name);

		try {
			fw = new FileWriter(file, true);
			pw = new PrintWriter(new BufferedWriter(fw));
			pw.print(new String(bytes, "utf-8"));
			pw.close();
			fw.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 生成文件并写入内容
	 * 
	 * @param fileName
	 * @param fileContent
	 * @param encoding
	 *            eg:utf-8
	 */
	public static void writeFile(String fileName, String fileContent, String encoding) {
		try {
			FileOutputStream fos = new FileOutputStream(fileName, true);
			OutputStreamWriter osw = new OutputStreamWriter(fos, encoding);
			osw.write(fileContent);
			osw.flush();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		List<Parameter> params = (List<Parameter>) readFile("message");
		System.out.println(params.size());
		System.out.println(params.get(0).getContent());
	}
}