package org.springside.bookstore.admin.manager;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.jbpm.JbpmContext;
import org.jbpm.JbpmException;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.taskmgmt.exe.TaskInstance;
import org.springmodules.workflow.jbpm31.JbpmCallback;
import org.springmodules.workflow.jbpm31.JbpmTemplate;
import org.springside.bookstore.admin.exception.OrderException;
import org.springside.bookstore.commons.domain.Order;
import org.springside.bookstore.commons.domain.OrderItem;
import org.springside.bookstore.commons.domain.Product;
import org.springside.core.commons.BaseHibernateDao;
import org.springside.core.utils.DateUtil;
import org.springside.plugins.jbossrules.RuleTemplate;
import org.springside.plugins.security.acl.intercept.AclCreatMethod;
import org.springside.plugins.security.acl.voter.AclDomainClass;

import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author calvin
 * @author Water Ye
 * @see BaseHibernateDao
 */
public class OrderManager extends BaseHibernateDao<Order> {
    private BookManager bookManager;

    private RuleTemplate pricingTemplate;

    private JbpmTemplate jbpmTemplate;

    public void setBookManager(BookManager bookManager) {
        this.bookManager = bookManager;
    }

    public void setPricingTemplate(RuleTemplate pricingTemplate) {
        this.pricingTemplate = pricingTemplate;
    }

    public void setJbpmTemplate(JbpmTemplate jbpmTemplate) {
        this.jbpmTemplate = jbpmTemplate;
    }

    /**
     * 订单发货
     */
    public void shipOrder(Order order) throws Exception {
        // 减少库存,如果库存不足则抛异常
        List<OrderItem> items = order.getOrderItems();
        for (OrderItem item : items) {
            Product book = item.getProduct();
            int newInventory = book.getInventory() - item.getQuantity();
            if (newInventory < 0)
                throw new OrderException(OrderException.LACK_INVENTORY, book);
            book.setInventory(newInventory);
            bookManager.save(book);
        }

        order.setShipDate(new Date());
        order.setStatus(Order.STATUS_SHIPPED);
        save(order);
    }

    /**
     * 下订单
     */
    @AclCreatMethod()
    public void placeOrder(Order order) {
        pricing(order);
        super.save(order);
        workflow(order);
    }

    /**
     * 使用规则引擎计算订单价格.
     *
     * @see RuleTemplate
     */
    public void pricing(Order order) {
        try {
            order.setOriginalPrice(order.getTotalPrice());
            if (pricingTemplate != null)
                //run rule engine
                pricingTemplate.executeRules(order);
        }
        catch (Exception e) {
            //为了plugin模块不影响主流程，catch所有error不往外抛
            logger.error("JBoss Rules error when place order:", e);
        }
    }

    /**
     * JBPM工作流演示
     */
    public void workflow(Order order) {
        // 将订单流程号加入 jBPM 流程
        if (jbpmTemplate != null) {
            try {
                final Integer orderId = order.getId();
                jbpmTemplate.execute(new JbpmCallback() {
                    public Object doInJbpm(JbpmContext jbpmContext) throws JbpmException {
                        ProcessInstance processInstance = jbpmContext.newProcessInstance("SimpleOrderFlow");
                        TaskInstance taskInstance = processInstance.getTaskMgmtInstance().createStartTaskInstance();
                        taskInstance.setActorId("Demo");
                        taskInstance.setVariable("order", orderId);
                        taskInstance.end();
                        return null;
                    }

                });
            }
            catch (Exception e) {
                //为了plugin模块不影响主流程，catch所有error不往外抛
                logger.error("JBPM Workflow error when place order:", e);
            }
        }
    }


    /**
     * 删除订单
     */
    @AclDomainClass(Order.class)
    public void removeOrder(Integer id) {
        Order order = get(id);

        // 如果订单已出货,删除订单将加回库存
        if (Order.STATUS_SHIPPED.equals(order.getStatus())) {
            List<OrderItem> items = order.getOrderItems();
            for (OrderItem item : items) {
                Product book = item.getProduct();
                int newInventory = book.getInventory() + item.getQuantity();
                book.setInventory(newInventory);
                bookManager.save(book);
            }
        }

        remove(order);
    }

    /**
     * 重载{@link BaseHibernateDao#findBy(Map)}函数, 按filter中的条件进行查询
     */
    public List findBy(Map filter) {
        Criteria criteria = getEntityCriteria();

        String id = (String) filter.get("id");
        if (StringUtils.isNotBlank(id))
            criteria.add(Restrictions.eq("id", new Integer(id)));

        String beginDate = (String) filter.get("beginDate");
        if (StringUtils.isNotEmpty(beginDate))

            try {
                criteria.add(Restrictions.ge("shipDate", DateUtil.parse(beginDate, "yyyy-MM-DD")));
            } catch (ParseException e) {
                throw new IllegalArgumentException("beginDate format error" + beginDate, e);
            }


        String endDate = (String) filter.get("endDate");
        if (StringUtils.isNotEmpty(endDate))
            try {
                criteria.add(Restrictions.le("shipDate", DateUtil.parse(endDate, "yyyy-MM-DD")));
            } catch (ParseException e) {
                throw new IllegalArgumentException("endDate format error" + beginDate, e);
            }

        String customer = (String) filter.get("customer");
        if (StringUtils.isNotEmpty(customer))
            criteria.createAlias("customer", "c").add(
                    Restrictions.like("c.name", "%" + customer + "%"));

        String status = (String) filter.get("status");
        if (StringUtils.isNotEmpty(status) && !"all".equals(status))
            criteria.add(Restrictions.eq("status", status));

        criteria.addOrder(org.hibernate.criterion.Order.asc("orderDate"));

        return criteria.list();
    }
}