package com.doumee.core.utils;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.binary.Hex;
//import org.apache.commons.httpclient.HttpClient;
//import org.apache.commons.httpclient.NameValuePair;
//import org.apache.commons.httpclient.methods.PostMethod;
//import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.*;
import org.apache.http.util.EntityUtils;

import java.io.*;
import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class HttpUtil {
	public static final String UTF8 = "UTF-8";

	/**
	 * @param urlpath
	 * @throws IOException
	 * @throws UnsupportedEncodingException
	 */
	public static String postRequestConn(String urlpath) throws UnsupportedEncodingException, IOException {
		String sendString = "";

		// 创建url对象
		URL url = new URL(urlpath);

		// 打开url连接
		HttpURLConnection connection = (HttpURLConnection) url.openConnection();
		connection.setRequestProperty("Content-Type", "application/octet-stream");
		// 设置url请求方式 ‘get’ 或者 ‘post’
		connection.setRequestMethod("POST");
		connection.setDoOutput(true);
		connection.setDoInput(true);
		connection.setUseCaches(true);
		connection.setConnectTimeout(3000);
		connection.setReadTimeout(10000);
		connection.setRequestProperty("Charset", "UTF-8");
		int responseCode = connection.getResponseCode();
		if (HttpURLConnection.HTTP_OK == responseCode) {
			String readLine;
			BufferedReader responseReader;
			StringBuffer sb = new StringBuffer();
			responseReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
			while ((readLine = responseReader.readLine()) != null) {
				sb.append(readLine).append("\n");
			}
			responseReader.close();
			sendString = sb.toString();
			// httpConn.disconnect();
		} else {
			System.out.println("error");
		}

		return sendString;
	}

	/**
	 * @param urlPath
	 * @param json
	 * @throws IOException
	 * @throws UnsupportedEncodingException
	 */
	public static String postRequestConn(String urlPath, String json,String tokenStr) throws UnsupportedEncodingException, IOException {
		String sendString = "";
		// try {
		URL url;
		url = new URL(urlPath);
		HttpURLConnection httpConn;
		httpConn = (HttpURLConnection) url.openConnection();
		// httpConn.connect();
		httpConn.setDoOutput(true);
		httpConn.setDoInput(true);
		httpConn.setRequestMethod("POST");
		httpConn.setUseCaches(false);
		httpConn.setInstanceFollowRedirects(true);
		httpConn.setRequestProperty("Content-Type", "application/json");
		httpConn.setRequestProperty("accept", "application/json");
		httpConn.setRequestProperty("X-Judge-Server-Token",getSHA256Str(tokenStr));
		httpConn.setConnectTimeout(10000);
		httpConn.setReadTimeout(10000);
		httpConn.connect();
		OutputStream out = httpConn.getOutputStream();
		byte[] data = (json.toString()).getBytes("UTF-8");
		out.write(data, 0, data.length);
		out.flush();
		out.close();
		int responseCode = httpConn.getResponseCode();
		if (HttpURLConnection.HTTP_OK == responseCode) {
			String readLine;
			BufferedReader responseReader;
			StringBuffer sb = new StringBuffer();
			responseReader = new BufferedReader(new InputStreamReader(httpConn.getInputStream(), "UTF-8"));
			while ((readLine = responseReader.readLine()) != null) {
				sb.append(readLine);
			}
			responseReader.close();
			sendString = sb.toString();
			// httpConn.disconnect();
		} else {
			System.out.println("error");
		}
		return sendString;
	}

	public static String doPost(String url,JSONObject json,String token) {
		DefaultHttpClient client = new DefaultHttpClient();
		HttpPost post = new HttpPost(url);
		String response = null;
		try {
			post.addHeader("Content-Type", "application/json; charset=utf-8");
			post.addHeader("X-Judge-Server-Token",getSHA256Str(token));
			StringEntity s = new StringEntity(json.toString());
			s.setContentEncoding("UTF-8");
			s.setContentType("application/json");//发送json数据需要设置contentType
			post.setEntity(s);
			HttpResponse res = client.execute(post);
			if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				HttpEntity entity = res.getEntity();
				response = EntityUtils.toString(entity);// 返回json格式：
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		// System.out.print(response);
		return response;
	}

	//java对象转map
	public static Map<String, Object> objectToMap(Object obj) throws Exception {
		if (obj == null) {
			return null;
		}
		Map<String, Object> map = new HashMap<>();
		Field[] declaredFields = obj.getClass().getDeclaredFields();
		for (Field field : declaredFields) {
			field.setAccessible(true);
			map.put(field.getName(), field.get(obj));
		}
		return map;
	}
//	public static String doFormPost(String url,JSONObject json) throws Exception{
//		String response = null;
//		HttpClient client = new HttpClient();
//		PostMethod postMethod = new PostMethod(url);
//		postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET,"utf-8");
//		Map<String, Object>  params =objectToMap(json);
//		if(params !=null && params.get("map") !=null ){
//			HashMap<String,String> map = (HashMap<String, String>) params.get("map");
//			if(map !=null   && !map.isEmpty()){
//			NameValuePair[] data = new NameValuePair[map.size()];
//			int i =0;
//			for(Map.Entry<String,String> entry : map.entrySet()){
//				data[i] = new NameValuePair(entry.getKey(),entry.getValue());
//				i++;
//			}
//			postMethod.setRequestBody(data);
//			}
//		}
//		try {
//			client.executeMethod(postMethod);
//			if(postMethod.getStatusCode() == HttpStatus.SC_OK){
//				response = postMethod.getResponseBodyAsString();
//			}
//		}catch (Exception e){
//			e.printStackTrace();
//		}
//		return response;
//	}


	public static void main(String[] args) throws IOException {
//		"language_config": sub_config["config"],
//				"src": code,
//				"max_cpu_time": self.problem.time_limit,
//				"max_memory": 1024 * 1024 * self.problem.memory_limit,
//				"test_case_id": self.problem.test_case_id,
//				"output": False,
//				"spj_version": self.problem.spj_version,
//				"spj_config": spj_config.get("config"),
//				"spj_compile_config": spj_config.get("compile"),
//				"spj_src": self.problem.spj_code,
//				"io_mode": self.problem.io_mode
/*
		{
			"template": "" ,

			 "compile": {
			"src_name": "main.cpp",
					"exe_name": "main",
					"max_cpu_time": 10000,
					"max_real_time": 20000,
					"max_memory": 1024 * 1024 * 1024,
					"compile_command": "/usr/bin/g++ -DONLINE_JUDGE -O2 -w -fmax-errors=3 -std=c++14 {src_path} -lm -o {exe_path}",
		},
			"run": {
			"command": "{exe_path}",
					"seccomp_rule": {ProblemIOMode.standard: "c_cpp", ProblemIOMode.file: "c_cpp_file_io"},
			"env": default_env
		}

		{"config": _cpp_lang_config, "spj": {"compile": _cpp_lang_spj_compile, "config": _cpp_lang_spj_config},
			"name": "C++", "description": "G++ 5.4", "content_type": "text/x-c++src"},*/
		JSONObject json =new JSONObject();
		JSONObject j = new JSONObject();
		JSONObject spj = new JSONObject();
		JSONObject sc = new JSONObject();
		sc.put("src_name","spj-{spj_version}.cpp");
		sc.put("exe_name","spj-{spj_version}");
		sc.put("max_cpu_time",10000);
		sc.put("max_real_time",20000);
		sc.put("max_memory",1024 * 1024 * 1024);
		sc.put("compile_command","/usr/bin/g++ -DONLINE_JUDGE -O2 -w -fmax-errors=3 -std=c++14 {src_path} -lm -o {exe_path}");
		spj.put("compile",sc);
		JSONObject scc = new JSONObject();
		scc.put("exe_name","spj-{spj_version}");
		scc.put("command","{exe_path} {in_file_path} {user_out_file_path}");
		scc.put("seccomp_rule","c_cpp");
		spj.put("config",scc);
		JSONObject compile = new JSONObject();
		compile.put("src_name", "main.cpp");
		compile.put("exe_name", "main");
		compile.put("max_cpu_time", 10000);
		compile.put("max_real_time", 20000);
		compile.put("max_memory",1024 * 1024 * 1024);
		compile.put("compile_command", "/usr/bin/g++ -DONLINE_JUDGE -O2 -w -fmax-errors=3 -std=c++14 {src_path} -lm -o {exe_path}");
		JSONObject run = new JSONObject();
		JSONObject sr = new JSONObject();
		sr.put("Standard IO","c_cpp");
		sr.put("File IO","c_cpp_file_io");
		run.put("command", "{exe_path}");
		run.put("seccomp_rule", sr);
		run.put("env",new  String[]{"LANG=en_US.UTF-8", "LANGUAGE=en_US:en", "LC_ALL=en_US.UTF-8"});
		JSONObject config = new JSONObject();
		config.put("template","//PREPEND BEGIN\n" +
				"#include <iostream>\n" +
				"//PREPEND END\n" +
				"\n" +
				"//TEMPLATE BEGIN\n" +
				"int add(int a, int b) {\n" +
				"  // Please fill this blank\n" +
				"  return ___________;\n" +
				"}\n" +
				"//TEMPLATE END\n" +
				"\n" +
				"//APPEND BEGIN\n" +
				"int main() {\n" +
				"  std::cout << add(1, 2);\n" +
				"  return 0;\n" +
				"}\n" +
				"//APPEND END");
		config.put("run",run);
		config.put("compile",compile);

		j.put("name","C++");
		j.put("description","G++ 5.4");
		j.put("content_type","text/x-c++src");
		j.put("config",config);
		j.put("spj",spj);

		json.put("language_config",j.get("config"));
		json.put("src","#include <stdio.h> // puts     \n" +
				"int main(){\n" +
				"  puts(\"Hello,World!\");// 输出\n" +
				"}");
		json.put("max_cpu_time",1000);
		json.put("max_memory",1024*1024*64);
		json.put("test_case_id","2b7e2f6a801b6c00388e717ae11b6f57");
//		json.put("output",Boolean.FALSE);
//		json.put("spj_version","");
//		json.put("spj_config","");
//		json.put("spj_compile_config","");
//		json.put("spj_src","");
//		json.put("io_mode","{\"input\": \"input.in\", \"output\": \"output.out\", \"io_mode\": \"Standard IO\"}");

		System.out.println(json.toJSONString());
		System.out.println(postRequestConn("http://47.100.55.21:8080/judge",json.toJSONString(),"3c8e8bd79d66259c46d8a3d057278dc8"));
	}

	public static String getSHA256Str(String str) {
		MessageDigest messageDigest;
		String encdeStr = "";
		try {
			messageDigest = MessageDigest.getInstance("SHA-256");
			byte[] hash = messageDigest.digest(str.getBytes("UTF-8"));
			encdeStr = Hex.encodeHexString(hash);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return encdeStr;
	}



	/**
	 * 下载二维码图片文件，
	 * 
	 * @param urlString
	 * @return 临时文件夹地址
	 * @throws Exception
	 */

	public static String downloadQrcode(String urlString) throws Exception {
		String savePath = System.getProperty("java.io.tmpdir");
		String nfix = ".jpg";// 文件后缀名
		String tempName = UUID.randomUUID().toString() + nfix;// 临时文件名

		// ----------------图片下载开始---------------
		// 构造URL
		URL url = new URL(urlString);
		// 打开连接
		URLConnection con = url.openConnection();
		// 设置请求超时为5s
		con.setConnectTimeout(5 * 1000);
		// 输入流
		InputStream is = con.getInputStream();

		// 1K的数据缓冲
		byte[] bs = new byte[1024];
		// 读取到的数据长度
		int len;
		// 输出的文件流
		File sf = new File(savePath);
		if (!sf.exists()) {
			sf.mkdirs();
		}
		String tempFilePath = sf.getPath() + "\\" + tempName;
		OutputStream os = new FileOutputStream(tempFilePath);
		// 开始读取
		while ((len = is.read(bs)) != -1) {
			os.write(bs, 0, len);
		}
		// 完毕，关闭所有链接
		os.close();
		is.close();
		// -------------------图片下载完毕------------------

		return tempFilePath;
	}
}