package com.myproject.manager.impl;

import com.myproject.bean.search.PageList;
import com.myproject.bean.update.*;
import com.myproject.dao.mongo.IBomDao;
import com.myproject.dao.mongo.IComponentDao;
import com.myproject.exception.ValidateException;
import com.myproject.manager.*;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by kangmor on 2015/10/15.
 */
@Service
public class BomManagerImpl implements IBomManager {

    @Autowired
    private IBomDao bomDao;

    @Autowired
    private IComponentDao componentDao;
    @Autowired
    private IStorageManager storageManager;
//    @Autowired
//    private IWarehousingManager warehousingManager;

    @Autowired
    private IStoragePosManager storagePosManager;

    @Autowired
    private IWorkOrderManager workOrderManager;


    protected final transient Logger log = LogManager.getLogger(getClass());

    @Override
    public Bom addComponent(Bom bom, String componentId, int amount) throws ValidateException {
        if (bom.getId() != null) {
            if (!StringUtils.isEmpty(componentId)) {
                Component component = componentDao.findOneById(componentId);
                if (component != null) {
                    if (amount < 0) {
                        amount = 0;
                    }
                    List<Comps> compsList = bom.getComponents();
                    boolean found = false;
                    if (compsList == null) {
                        compsList = new ArrayList<Comps>();
                    } else {
                        for (Comps comps : compsList) {
                            if (componentId.equals(comps.getComponentId())) {
                                comps.setAmount(amount);
                                found = true;
                                break;
                            }
                        }
                    }
                    if (!found) {
                        Comps comps = new Comps(componentId, amount);
                        compsList.add(comps);
                    }
                    bom.setComponents(compsList);
                    save(bom);
                }
            }
        }
        return bom;
    }

    public List<StoragePos> checkoutPerComponent(WorkOrder workOrder) throws ValidateException {
        List<Component> outOfStockList = new ArrayList();
        log.debug("Start to checkout Bom: " + workOrder.getBom().getId() + " with one per component");
        List<Comps> components = workOrder.getBom().getComponents();
        List<UsedComponent> usedComponents = workOrder.getUsedComponentList();
        if (usedComponents == null) {
            usedComponents = new ArrayList<>();
        }
        List<StoragePos> storagePosList = new ArrayList<>();
        if (components != null && components.size() > 0) {
            for (Comps comps : components) {
                StoragePos storagePos = storagePosManager.findComponent(comps.getComponentId());
                if (storagePos != null) {
                    Storage storage = storageManager.get(storagePos.getStorageId());
                    int checkoutAmount = comps.getAmount() * workOrder.getAmount();

                    if (storagePos.getBarcode().getAmount() < checkoutAmount) {
                        checkoutAmount = storagePos.getBarcode().getAmount();
                    }
                    //TODO:暂时注释掉
                    //warehousingManager.prepareCheckout(storage.getCid(), storagePos.getBarcode().getBarcode(), checkoutAmount);
                    UsedComponent usedComponent = new UsedComponent();
                    usedComponent.setAmount(checkoutAmount);
                    usedComponent.setBarcodeId(storagePos.getBarcode().getId());
                    //usedComponent.setComponentId(storagePos.getBarcode().getComponentId());
                    usedComponents.add(usedComponent);
                    storagePosList.add(storagePos);
                } else {
                    Component component = componentDao.findOneById(comps.getComponentId());
                    outOfStockList.add(component);
                }
            }
        }
        workOrder.setUsedComponentList(usedComponents);
        workOrderManager.save(workOrder);

        if (outOfStockList != null && outOfStockList.size() > 0) {
            StringBuffer componentNames = new StringBuffer();
            for (Component component : outOfStockList) {
                componentNames.append(component.getName() + " ");
            }
            log.error("Component: " + componentNames.toString() + " are out of stock");
            throw new ValidateException("bom.error.outOfStock", new String[]{componentNames.toString()});
        }
        return storagePosList;
    }

    @Override
    public Bom findByName(String name) {
        log.debug("Find bom by bom name " + name);
        if (StringUtils.isEmpty(name))
            return null;
        else return bomDao.findOneByCondition(new String[]{"name"}, new String[]{name});
    }

    @Override
    public Bom removeComponent(Bom bom, String componentId) throws ValidateException {
        boolean doSave = false;
        if (bom.getId() != null) {
            if (!StringUtils.isEmpty(componentId)) {
                if (bom.getComponents() != null && bom.getComponents().size() > 0) {
                    for (Comps comps : bom.getComponents()) {
                        if (componentId.equals(comps.getComponentId())) {
                            bom.getComponents().remove(comps);
                            doSave = true;
                            break;
                        }
                    }
                }
            }
        }
        if (doSave) {
            save(bom);
        }
        return bom;
    }

    @Override
    public Bom get(String id) {
        return bomDao.findOneById(id);
    }

    @Override
    public Bom save(Bom bom) throws ValidateException {
        validateUniqueName(bom);
        log.debug("Save bom with name " + bom.getName());
        return bomDao.save(bom);
    }

    protected void validateUniqueName(Bom bom) throws ValidateException {
        Bom savedBom = findByName(bom.getName());
        if (savedBom != null && !savedBom.getId().equals(bom.getId())) {
            throw new ValidateException("bom.error.unique", new String[]{bom.getName()});
        }

    }

    @Override
    public void delete(Bom object) throws ValidateException {
        bomDao.removeOne(object);
    }

    @Override
    public List<Bom> findAll() {
        return bomDao.findAll();
    }

    @Override
    public PageList findByQuery(Query query, PageList pageList) {
        pageList.setList(bomDao.findByQuery(query, pageList.getPageNumber(), pageList.getObjectsPerPage()));
        pageList.setFullListSize(bomDao.countByQuery(query));
        return pageList;
    }

    @Override
    public void validate(Bom object, List errors) {

    }

    public void setBomDao(IBomDao bomDao) {
        this.bomDao = bomDao;
    }

    public void setComponentDao(IComponentDao componentDao) {
        this.componentDao = componentDao;
    }

    public void setWorkOrderManager(IWorkOrderManager workOrderManager) {
        this.workOrderManager = workOrderManager;
    }
}