package com.yeshi.fanli.service.impl.order;

import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.yeshi.utils.NumberUtil;

import com.yeshi.fanli.dao.mybatis.order.LostOrderMapper;
import com.yeshi.fanli.dao.order.LostOrderDao;
import com.yeshi.fanli.dao.order.PidOrderDao;
import com.yeshi.fanli.entity.bus.user.LostOrder;
import com.yeshi.fanli.entity.bus.user.Order;
import com.yeshi.fanli.service.inter.order.LostOrderService;
import com.yeshi.fanli.service.inter.order.OrderService;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.Utils;

@Service
public class LostOrderServiceImpl implements LostOrderService {

	@Resource
	private OrderService orderService;

	@Resource
	private LostOrderDao lostOrderDao;

	@Resource
	private PidOrderDao pidOrderDao;

	@Resource
	private LostOrderMapper lostOrderMapper;

	@Override
	public int addLostOrder(LostOrder lostOrder) {
		String orderId = lostOrder.getOrderId();
		Integer type = lostOrder.getType();
		if (type == null) { // 默认为淘宝订单
			lostOrder.setType(1);
			type = 1;
		}

		// 查询是否提交
		List<LostOrder> orderList = lostOrderMapper.selectByOrderId(orderId);
		if (orderList != null && orderList.size() > 0) {
			if (orderList.get(0).getState() == 0 || orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_VERFING) {
				return -2;
			} else if (orderList.get(0).getState() == 1
					&& orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_SUCCESS) {
				return -1;
			} else {
				return -6;
			}
		}

		Order order = orderService.findOrderByOrderIdAndType(orderId, type);
		if (order != null) {
			return -3;
		}

		// 查询是否为分享赚订单
		if (pidOrderDao.list("from PidOrder p where p.orderId=?", new Serializable[] { orderId }).size() > 0)
			return -5;

		WriteLock lostOrderwriteLock = lostOrderLock.writeLock();
		ReadLock lostOrderReadLock = lostOrderLock.readLock();
		try {
			try {
				lostOrderwriteLock.lock();
				List<LostOrder> list = lostOrderDao.list(
						"from LostOrder lo where lo.orderId= ? and lo.type = ? and (lo.state = 0 or lo.state = 1)", 0,
						1, new Serializable[] { orderId, type });
				if (list.size() > 0) {
					LostOrder find = list.get(0);
					Integer state = find.getState();
					if (state == 0) {
						return -2;
					} else if (state == 1) {
						return -1;
					}
				}
			} finally {
				lostOrderReadLock.lock();
				lostOrderwriteLock.unlock();
			}
			lostOrder.setState(0);
			lostOrder.setHandleTime(0L);
			lostOrder.setCreateTime(System.currentTimeMillis());
			Order or = orderService.getSystemOrderByUid(Constant.TAOBAO, lostOrder.getUserInfo().getId());
			if (or != null) {
				boolean b = Utils.isUserOrder(or.getOrderId(), lostOrder.getOrderId());
				if (b) {
					lostOrder.setJudge("匹配");

				} else {
					lostOrder.setJudge("不匹配");
				}
			} else {
				lostOrder.setJudge("不匹配");
			}
			lostOrderDao.save(lostOrder);
		} finally {
			lostOrderReadLock.unlock();
		}
		return 0;
	}

	public void pass(LostOrder lostOrder) {
		Order order = new Order();
		order.setBeizhu("补单");
		order.setCreatetime(lostOrder.getCreateTime());
		order.setOrderId(lostOrder.getOrderId());
		order.setOrderType(lostOrder.getType());
		order.setState(1);
		order.setUserInfo(lostOrder.getUserInfo());
		try {
			boolean b = orderService.addOrder(order);
			if (b) {
				lostOrder.setRemake("处理成功");
				lostOrder.setState(1);
				lostOrder.setOrder(order);
			} else {
				lostOrder.setRemake("订单已存在!");
				lostOrder.setState(2);
			}
		} catch (Exception e) {
			e.printStackTrace();
			String message = e.getMessage();
			if (message.length() > 255) {
				message = message.substring(0, 255);
			}
			lostOrder.setRemake(e.getMessage());
			lostOrder.setState(2);
		}
		lostOrder.setHandleTime(System.currentTimeMillis());
		lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);
		lostOrderDao.update(lostOrder);
	}

	public void reject(LostOrder lostOrder) {
		lostOrder.setHandleTime(System.currentTimeMillis());
		lostOrder.setState(2);
		lostOrderDao.update(lostOrder);
	}

	@Override
	public List<LostOrder> findLostOrderList(String key, int page) {
		List<LostOrder> list;
		if (key == null || "".equals(key.trim())) {
			list = lostOrderDao.list("from LostOrder lo order by id desc", (page - 1) * Constant.PAGE_SIZE,
					Constant.PAGE_SIZE, new Serializable[] {});
		} else {
			if (NumberUtil.isNumeric(key) && key.length() >= 18) {
				// long id = Long.parseLong(key);
				list = lostOrderDao.list("from LostOrder lo where lo.orderId like ? order by id desc",
						(page - 1) * Constant.PAGE_SIZE, Constant.PAGE_SIZE, new Serializable[] { "%" + key + "%" });

			} else {

				list = lostOrderDao.list("from LostOrder lo where lo.userInfo.nickName like ? order by id desc",
						(page - 1) * Constant.PAGE_SIZE, Constant.PAGE_SIZE, new Serializable[] { "%" + key + "%" });
			}

		}
		return list;
	}

	@Override
	public int getCount(String key) {
		int count = 0;
		if (key == null || "".equals(key.trim())) {
			count = (int) lostOrderDao.getCount("select count(*) from LostOrder");
		} else {

			if (NumberUtil.isNumeric(key) && key.length() >= 18) {
				// long id = Long.parseLong(key);
				count = (int) lostOrderDao.getCount("select count(*) from LostOrder lo where lo.orderId like ?",
						new Serializable[] { "%" + key + "%" });
			} else {

				count = (int) lostOrderDao.getCount(
						"select count(*) from LostOrder lo where lo.userInfo.nickName like ?",
						new Serializable[] { "%" + key + "%" });
			}
		}
		return count;
	}

	@Override
	public LostOrder getOne(long id) {
		return lostOrderDao.find(LostOrder.class, id);
	}

	@Override
	public List<LostOrder> getLostOrderListByUid(Long uid, int page, int pageSize) {

		return lostOrderDao.list("from LostOrder lo where lo.userInfo.id=? order by lo.createTime desc",
				(page - 1) * pageSize, pageSize, new Serializable[] { uid });
	}

	@Override
	public long getLostOrderCountByUid(Long uid) {
		return lostOrderDao.getCount("select count(*)  from LostOrder lo where lo.userInfo.id=?",
				new Serializable[] { uid });
	}

	@Transactional
	@Override
	public void processSuceess(String orderId) {
		// 查询订单号是否在申诉列表中
		List<LostOrder> list = lostOrderMapper.selectByOrderId(orderId);
		if (list == null || list.size() == 0)
			return;
		for (LostOrder lo : list) {
			if (lo.getState() == 1 && lo.getResultCode() != null
					&& lo.getResultCode() == LostOrder.RESULT_CODE_VERFING) {
				LostOrder update = new LostOrder();
				update.setId(lo.getId());
				update.setResultCode(LostOrder.RESULT_CODE_SUCCESS);
				lostOrderMapper.updateByPrimaryKeySelective(update);
			}
		}
	}

	@Override
	public void processFail(String orderId) {
		lostOrderDao.update("update LostOrder lo set lo.resultCode=? where lo.orderId=?",
				new Serializable[] { LostOrder.RESULT_CODE_FAIL, orderId });
	}

	@Override
	public void processFail() {
		// 订单申诉人工通过后，但是隔了3天还未处理成功就视为该订单申诉失败
		lostOrderDao.update(
				"update LostOrder lo set lo.resultCode=? where lo.state=1 and lo.resultCode=? and lo.handleTime<?",
				new Serializable[] { LostOrder.RESULT_CODE_FAIL, LostOrder.RESULT_CODE_VERFING,
						System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 3L });
	}

	@Override
	public void deleteLostOrder(long id) {
		LostOrder lostOrder = new LostOrder();
		lostOrder.setId(id);
		lostOrderDao.delete(lostOrder);
	}

	@Override
	public void deleteLostOrderByUid(long uid) {
		lostOrderDao.update("delete from LostOrder lo where lo.userInfo.id=?", new Serializable[] { uid });
	}

	@Override
	public Map<String, Object> countByUid(long uid) {
		return lostOrderMapper.countByUid(uid);
	}

	/**
	 * 后端列表查询
	 * 
	 * @param start
	 * @param count
	 * @param key
	 * @return
	 */
	@Override
	public List<LostOrder> listQuery(long start, int count, String key, Integer state, Integer handleType) {
		return lostOrderMapper.listQuery(start, count, key, state, handleType);
	}

	@Override
	public long countQuery(String key, Integer state, Integer handleType) {
		return lostOrderMapper.countQuery(key, state, handleType);
	}
	
	
	@Override
	public List<Map<String, Object>> countLostNum( Integer dateType, Integer resultCode, 
			String year, String startTime, String endTime) throws Exception {
		return lostOrderMapper.countLostNum(dateType, resultCode, year, startTime, endTime);
	}
	
	
	@Override
	public List<Map<String, Object>> countAppealMoney( Integer dateType, String year, String startTime, 
			String endTime) throws Exception {
		return lostOrderMapper.countAppealMoney(dateType, year, startTime, endTime);
	}
	
}