package com.yami.trading.admin.controller.miner;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yami.trading.admin.facade.PermissionFacade;
import com.yami.trading.common.util.*;
import com.yami.trading.service.miner.job.MinerOrderProfitJob;
import com.yami.trading.bean.miner.Miner;
import com.yami.trading.bean.miner.MinerOrder;
import com.yami.trading.common.domain.Result;
import com.yami.trading.common.exception.BusinessException;
import com.yami.trading.security.common.util.SecurityUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.yami.trading.service.miner.service.AdminMinerOrderService;
import com.yami.trading.service.miner.service.MinerOrderService;
import com.yami.trading.service.miner.service.MinerService;


/**
 * 管理后台-矿机订单页面
 *
 */
@RestController
@CrossOrigin
public class AdminMinerOrderController {

	private Logger logger = LogManager.getLogger(AdminMinerOrderController.class);
	
	@Autowired
	protected AdminMinerOrderService adminMinerOrderService;
	@Autowired
	protected MinerOrderService minerOrderService;
	@Autowired
	protected MinerService minerService;
	@Autowired
	protected MinerOrderProfitJob minerOrderProfitJob;

	@Autowired
	private PermissionFacade permissionFacade;
	
	protected Map<String, Object> session = new HashMap<>();
	
	private final String action = "normal/adminMinerOrderAction!";
	
	@RequestMapping(action + "list.action")
	public Result list(HttpServletRequest request) {

//		this.checkAndSetPageNo(request.getParameter("pageNo"));
		String name_para = request.getParameter("name_para");
		String miner_para = request.getParameter("miner_para");
		String status_para = request.getParameter("status_para");
		String order_no_para = request.getParameter("order_no_para");
		String rolename_para = request.getParameter("rolename_para");

		int pageNo = Integer.parseInt(request.getParameter("current"));
		int pageSize = Integer.parseInt(request.getParameter("size"));

		List<String> children = permissionFacade.getOwnerUserIds();

		//&current=1&size=10
		
//		String partyId = getLoginPartyId();
		String partyId = null;//SecurityUtils.getCurrentSysUserId();
		List<Miner> findAll = this.minerService.findAll();
		Map<String, String> miner_name_map = new LinkedHashMap<String, String>();
		for (Miner miner : findAll) {
			miner_name_map.put(miner.getUuid(), miner.getName());
		}

		Page page = this.adminMinerOrderService.pagedQuery(pageNo, pageSize, name_para, miner_para,
				status_para, children, order_no_para, rolename_para);
//		ModelAndView model = new ModelAndView();
//		model.addObject("pageNo", pageNo);
//		model.addObject("pageSize", pageSize);
//		model.addObject("page", page);
//		model.addObject("name_para", name_para);
//		model.addObject("miner_para", miner_para);
//		model.addObject("status_para", status_para);
//		model.addObject("order_no_para", order_no_para);
//		model.addObject("rolename_para", rolename_para);
//
//		model.addObject("miner_name_map", miner_name_map);
//		model.addObject("message", message);
//		model.addObject("error", error);
//		model.setViewName("miner_order_list");
		return Result.ok(page);
	}

	/**
	 * 后台赎回
	 */
	@RequestMapping(action + "close.action")
	public Result closOrder(HttpServletRequest request) {
		String message = "";
		String error = "";
		Map<String,Object> map = new HashMap<>();
		try {
			String order_no = request.getParameter("order_no");
			System.out.println("order_no => "+order_no);
			MinerOrder order = minerOrderService.findByOrder_no(order_no);
			System.out.println("order.getMiner_id() => "+order.getMiner_id());
			Miner miner = minerService.findById(order.getMiner_id());

			CloseDelayThread lockDelayThread = new CloseDelayThread(order_no, minerOrderService);
			Thread t = new Thread(lockDelayThread);
			t.start();
			message = "操作成功";
		} catch (BusinessException e) {
			error = e.getMessage();
			return Result.failed(error);
		} catch (Exception e) {
			logger.error("error ", e);
			error = "程序错误";
			return Result.failed(error);
		}
//		ModelAndView model = new ModelAndView();
//		model.addObject("message", message);
//		model.addObject("error", error);
//		model.setViewName("redirect:/" + action + "list.action");
		return Result.succeed(map);
	}

	/**
	 * 新线程处理，直接拿到订单锁处理完成后退出
	 *
	 */
	public class CloseDelayThread implements Runnable {
		private String orderNo;
		private MinerOrderService minerOrderService;

		public void run() {
			try {
				while (true) {
					/**
					 * 提前赎回理财产品需要支付违约金
					 */
					MinerOrder order = minerOrderService.findByOrder_no(orderNo);

					Miner miner = minerService.findById(order.getMiner_id());

					Date date_now = new Date();// 取时间
					double last_days = daysBetween(order.getCreate_time(), date_now);
					if ("1".equals(order.getState()) && last_days >= miner.getCycle_close()) {
						/**
						 * 扣除违约金
						 */
						double default_money = 0d;// 不计违约金
						order.setState("2");
						order.setProfit(Arith.sub(order.getProfit(), default_money));
						this.minerOrderService.saveClose(order);
					}
					/**
					 * 处理完退出
					 */
					break;
				}

			} catch (Exception e) {
				logger.error("error:", e);
			}

		}

		public CloseDelayThread(String orderNo, MinerOrderService minerOrderService) {
			this.orderNo = orderNo;
			this.minerOrderService = minerOrderService;
		}

	}

	@RequestMapping(action + "toAddOrder.action")
	public Result toAddOrder(HttpServletRequest request) {
		String session_token = UUID.randomUUID().toString();
		this.session.put("session_token", session_token);

		List<Miner> findAll = this.minerService.findAll();
		Map<String, String> miner_name_map = new LinkedHashMap<String, String>();
		List<Miner> miner_list = new LinkedList<Miner>();
		for (Miner miner : findAll) {
			miner_name_map.put(miner.getUuid(), miner.getName());
			miner_list.add(miner);
		}
		Map<String,Object> map = new HashMap<>();
		map.put("miner_name_map", miner_name_map);
		map.put("miner_list", miner_list);
		map.put("session_token", session_token);
		return Result.ok(map);
	}

	@RequestMapping(action + "addOrder.action")
	public Result addOrder(HttpServletRequest request) {

		String error = "";
		try {
			String session_token = request.getParameter("session_token");
			String para_uid = request.getParameter("para_uid");
			// 购买金额
			String para_amount = request.getParameter("para_amount");
			// 矿机id
			String para_minerid = request.getParameter("para_minerid");
			
//			Object object = this.session.get("session_token");
//			this.session.remove("session_token");
//			if ((object == null) || (StringUtils.isNullOrEmpty(session_token))
//					|| (!session_token.equals((String) object))) {
//				return Result.failed("token");
//			}

			error = verifyAddOrder(para_uid, para_amount, para_minerid);
			if (!StringUtils.isNullOrEmpty(error)) {
//				model.addObject("error", error);
//				model.setViewName("miner_order_add");
				return Result.failed(error);
			}

			Object object = new Object();
			synchronized (object) {
				String username = SecurityUtils.getSysUser().getUsername();
				adminMinerOrderService.addOrder(para_uid, Double.valueOf(para_amount), para_minerid, username);
				ThreadUtils.sleep(100);
			}
//			model.addObject("message", "操作成功");
//			model.setViewName("redirect:/" + action + "list.action");
			return Result.ok("操作成功");
		} catch (BusinessException e) {
//			model.addObject("error", e.getMessage());
			return Result.failed(e.getMessage());
		} catch (Exception e) {
			logger.error("error ", e);
//			model.addObject("error", "程序错误");
//			model.setViewName("miner_order_add");
			return Result.failed("程序错误");
		}
	}

	protected String verifyAddOrder(String para_uid, String para_amount, String para_minerid) {
		if (StringUtils.isEmptyString(para_uid)) {
			return "请输入用户uid";
		}
			
		if (StringUtils.isNullOrEmpty(para_amount) 
				|| !StringUtils.isDouble(para_amount) 
				|| Double.valueOf(para_amount)< 0) {
			return "购买金额不能小于0";
		}
		
		if (StringUtils.isEmptyString(para_minerid)) {
			return "请选择要购买的矿机";
		}
		return null;
	}
	
	@RequestMapping(action + "addProfit.action")
	public Result addProfit(HttpServletRequest request) {
		String message = "";
		String error = "";
		String system_time = request.getParameter("system_time");
		try {
			String username = SecurityUtils.getSysUser().getUsername();
			if (!"root".equals(username) && !"admin".equals(username)) {
				throw new BusinessException("权限不足");
			}
			if (StringUtils.isEmptyString(system_time)) {
				throw new BusinessException("请填入系统时间");
			}

			Date newTime = DateTimeTools.readQueryTime(system_time, DateUtils.NORMAL_DATE_FORMAT, null);
			//JobDelayThread thread = new JobDelayThread(DateUtils.toDate(system_time, DateUtils.NORMAL_DATE_FORMAT), minerOrderProfitJob);
			JobDelayThread thread = new JobDelayThread(newTime, minerOrderProfitJob);
			Thread t = new Thread(thread);
			t.start();
			message = "操作成功";
		} catch (BusinessException e) {
			error = e.getMessage();
//			System.out.println("error = " + error);
			return Result.failed(e.getMessage());
		} catch (Exception e) {
			logger.error("error ", e);
//			System.out.println("error " + e);
			error = "程序错误";
			return Result.failed(e.getMessage());
		}
//		ModelAndView model = new ModelAndView();
		Map<String,Object> map = new HashMap<>();
		map.put("message", message);
		map.put("error", error);
		return Result.ok(map);
	}

	
	public class JobDelayThread implements Runnable {
		private MinerOrderProfitJob minerOrderProfitJob;
		private Date systemTime;
		public void run() {
			minerOrderProfitJob.handleData(systemTime);
		}

		public JobDelayThread(Date systemTime, MinerOrderProfitJob minerOrderProfitJob) {
			this.systemTime = systemTime;
			this.minerOrderProfitJob = minerOrderProfitJob;
		}

	}

	public static int daysBetween(Date smdate, Date bdate) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		smdate = sdf.parse(sdf.format(smdate));
		bdate = sdf.parse(sdf.format(bdate));
		Calendar cal = Calendar.getInstance();
		cal.setTime(smdate);
		long time1 = cal.getTimeInMillis();
		cal.setTime(bdate);
		long time2 = cal.getTimeInMillis();
		long between_days = (time2 - time1) / (1000 * 3600 * 24);

		return Integer.parseInt(String.valueOf(between_days));
	}

}