/*******************************************************************************
 *  Imixs Workflow 
 *  Copyright (C) 2001, 2011 Imixs Software Solutions GmbH,  
 *  http://www.imixs.com
 *  
 *  This program is free software; you can redistribute it and/or 
 *  modify it under the terms of the GNU General Public License 
 *  as published by the Free Software Foundation; either version 2 
 *  of the License, or (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
 *  General Public License for more details.
 *  
 *  You can receive a copy of the GNU General Public
 *  License at http://www.gnu.org/licenses/gpl.html
 *  
 *  Project: 
 *  	http://www.imixs.org
 *  	http://java.net/projects/imixs-workflow
 *  
 *  Contributors:  
 *  	Imixs Software Solutions GmbH - initial API and implementation
 *  	Ralph Soika - Software Developer
 *******************************************************************************/

package com.alexanderlogistics;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.logging.Logger;

import org.eclipse.microprofile.config.inject.ConfigProperty;
import org.imixs.workflow.ItemCollection;
import org.imixs.workflow.ItemCollectionComparator;
import org.imixs.workflow.engine.DocumentService;
import org.imixs.workflow.engine.WorkflowService;
import org.imixs.workflow.engine.index.SchemaService;
import org.imixs.workflow.exceptions.AccessDeniedException;
import org.imixs.workflow.exceptions.ModelException;
import org.imixs.workflow.exceptions.PluginException;
import org.imixs.workflow.exceptions.ProcessingErrorException;
import org.imixs.workflow.exceptions.QueryException;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.security.DeclareRoles;
import jakarta.annotation.security.RolesAllowed;
import jakarta.annotation.security.RunAs;
import jakarta.ejb.Singleton;
import jakarta.inject.Inject;

/**
 * Der BusinessPartnerService stellt Methoden für den Zugriff auf Business
 * Partner bereit.
 * 
 * @author rsoika
 * 
 */

@DeclareRoles({ "org.imixs.ACCESSLEVEL.NOACCESS", "org.imixs.ACCESSLEVEL.READERACCESS",
        "org.imixs.ACCESSLEVEL.AUTHORACCESS", "org.imixs.ACCESSLEVEL.EDITORACCESS",
        "org.imixs.ACCESSLEVEL.MANAGERACCESS" })
@RolesAllowed({ "org.imixs.ACCESSLEVEL.NOACCESS", "org.imixs.ACCESSLEVEL.READERACCESS",
        "org.imixs.ACCESSLEVEL.AUTHORACCESS", "org.imixs.ACCESSLEVEL.EDITORACCESS",
        "org.imixs.ACCESSLEVEL.MANAGERACCESS" })
@Singleton
@RunAs("org.imixs.ACCESSLEVEL.MANAGERACCESS")
public class BusinessPartnerService {

    public static final int MAX_SEARCH_RESULT = 100;
    public static final String ITEM_IBAN_LIST = "partner.bank.list";
    public static final String WORKFLOW_SERVICE_ENDPOINT = "workflow.service.endpoint";
    public static final String WORKFLOW_SERVICE_USER = "workflow.service.user";
    public static final String WORKFLOW_SERVICE_PASSWORD = "workflow.service.password";

    public static final String ERROR_BUSINESSPARTNER_MISSING = "ERROR_BUSINESSPARTNER_MISSING";
    public static final String ERROR_BUSINESSPARTNER_LOCKED = "ERROR_BUSINESSPARTNER_LOCKED";
    public static final String ERROR_BUSINESSPARTNER_VERIFICATION = "ERROR_BUSINESSPARTNER_VERIFICATION";

    public static final int TASK_ACTIVE = 1100;
    public static final int TASK_VERIFICATION = 1300;
    public static final int TASK_INACTIVE = 1700;
    public static final int TASK_LOCKED = 1800;
    public static final int EVENT_ACTIVATE = 210;

    private static Logger logger = Logger.getLogger(BusinessPartnerService.class.getName());

    @Inject
    @ConfigProperty(name = WORKFLOW_SERVICE_ENDPOINT)
    Optional<String> workflowServiceEndpoint;

    @Inject
    @ConfigProperty(name = WORKFLOW_SERVICE_USER)
    Optional<String> workflowServiceUser;

    @Inject
    @ConfigProperty(name = WORKFLOW_SERVICE_PASSWORD)
    Optional<String> workflowServicePassword;

    @Inject
    DocumentService documentService;

    @Inject
    WorkflowService workflowService;

    @Inject
    SchemaService schemaService;

    /**
     * Initialize the rest clients
     */
    @PostConstruct
    public void init() {

    }

    /**
     * Diese Methode aktualisiert das business Partner object. Sie wird von den
     * Invoice Plugins genutzt.
     * Die Methode wirft eine PluginException falls das BusinessPartner Objekt
     * gesperrt oder in verification ist!
     * 
     * Gleichzeitig wird bei Rechnungen in Abhängigkeit der Rechnungsart die
     * dbtr./cdtr. items sowie mail und country aktualisiert.
     * 
     * @param partnerID
     * @param workitem
     * @throws PluginException
     */
    public void updateBusinessPartnerData(ItemCollection workitem) throws PluginException {
        String partnerID = workitem.getItemValueString("partner.id");
        // Migration wenn keine partner.id existier!
        if (partnerID.isEmpty()) {
            if (InvoiceUtil.isCreditorInvoice(workitem)) {
                partnerID = InvoiceUtil.buildBPID(workitem.getItemValueString("cdtr.number"));
            }
            if (InvoiceUtil.isDebitorInvoice(workitem)) {
                partnerID = InvoiceUtil.buildBPID(workitem.getItemValueString("dbtr.number"));
            }
            workitem.setItemValue("partner.id", partnerID);
        }

        // load Business Partner
        ItemCollection businessPartner = getBusinessPartnerByID(partnerID);
        if (businessPartner != null) {
            workitem.setItemValue("partner.name", businessPartner.getItemValueString("partner.name"));

            // Update Invoice Partner Meta Data
            if (InvoiceUtil.isDebitorInvoice(workitem)) {
                workitem.setItemValue("dbtr.number", businessPartner.getItemValueString("dbtr.number"));
                workitem.setItemValue("dbtr.name", businessPartner.getItemValueString("partner.name"));
                workitem.setItemValue("dbtr.mail", businessPartner.getItemValueString("dbtr.mail"));
                workitem.setItemValue("invoice.country", businessPartner.getItemValueString("_vendor_country"));
            }
            if (InvoiceUtil.isCreditorInvoice(workitem)) {
                workitem.setItemValue("cdtr.number", businessPartner.getItemValueString("cdtr.number"));
                workitem.setItemValue("cdtr.name", businessPartner.getItemValueString("partner.name"));
                workitem.setItemValue("cdtr.mail", businessPartner.getItemValueString("cdtr.mail"));
                workitem.setItemValue("invoice.country", businessPartner.getItemValueString("_vendor_country"));
            }

            // Validate Business Partner Status!
            if (businessPartner.getTaskID() == TASK_VERIFICATION) {
                throw new PluginException(InvoicePlugin.class.getName(),
                        ERROR_BUSINESSPARTNER_VERIFICATION,
                        "Businesspartner is in verification. Invoice can't be processed!");
            }
            if (businessPartner.getTaskID() == TASK_LOCKED) {
                throw new PluginException(InvoicePlugin.class.getName(),
                        ERROR_BUSINESSPARTNER_LOCKED,
                        "Businesspartner is locked. Invoice can't be processed!");
            }
            // update business partner status...
            try {
                if (businessPartner.getTaskID() == TASK_INACTIVE) {
                    // Workitem erneut aktivieren
                    businessPartner.event(EVENT_ACTIVATE);
                    workflowService.processWorkItem(businessPartner);
                } else {
                    // workItem einfach nur speichern!
                    documentService.save(businessPartner);
                }
            } catch (PluginException | ProcessingErrorException | AccessDeniedException | ModelException e) {
                logger.warning("Failed to update BusinessPartner object '" + partnerID + "'!");
            }
        } else {
            logger.warning("BusinessPartner '" + partnerID + "' not found!");
        }
    }

    /**
     * Returns the stubs of all outgoing invoices
     * 
     * @param _dbtrNumber
     * @return
     */
    public List<ItemCollection> findOutgoingInvoices(String _dbtrNumber) {
        // Aus der dbtrNummer muss das führendde D entfernt werden
        String query = "(type:workitem) AND ($modelversion:rechnungsausgang-*)";

        // Aus der dbtrNummer muss das führendde D entfernt werden
        // wir speichern dieses zwar im Zahlungseingangs Workflow, aber eine
        // Ausganksrechnung kennt das nicht
        // Das ganze ist ein übles Relikt aus Cargosoft und kann nicht vermieden werden
        String _dbtrNumberOld = _dbtrNumber;
        if (_dbtrNumberOld.startsWith("D")) {
            _dbtrNumberOld = _dbtrNumber.substring(1);
        }
        query = query + "  AND (dbtr.number:" + _dbtrNumber + " OR dbtr.number:" + _dbtrNumberOld + ")";

        try {
            return documentService.find(query, 999, 0, "invoice.number", false);
        } catch (QueryException e) {
            logger.severe("Failed to compute outgoing invoices: " + e.getMessage());
        }

        return new ArrayList<>();
    }

    /**
     * Diese Methode sucht einen Business Partner anhand seiner BPID
     * 
     * @param bpid
     *             - business partner id phrase
     * @return - matching business partner
     */
    public ItemCollection getBusinessPartnerByID(String bpid) {
        if (bpid == null || bpid.isEmpty()) {
            return null;
        }
        List<ItemCollection> result;
        try {
            String sQuery = "(type:\"workitem\"  OR type:\"workitemarchive\" ) AND ($modelversion:businesspartner-*)";
            sQuery += " AND (name:" + bpid.trim() + ")";
            logger.finest("SearchQuery= " + sQuery);
            result = documentService.find(sQuery, 1, 0);
            if (result.size() > 0) {
                return result.get(0);
            }
        } catch (Exception e) {
            logger.warning("  lucene error - " + e.getMessage());
        }
        return null;
    }

    /**
     * Diese Methode sucht Business Partner anhand einer Suchphrase
     * 
     * @param phrase
     *               - search phrase
     * @return - list of matching business partners
     */
    public List<ItemCollection> search(String phrase) {

        List<ItemCollection> searchResult = new ArrayList<ItemCollection>();
        if (phrase == null || phrase.isEmpty()) {
            return searchResult;
        }

        try {
            phrase = phrase.trim();
            // phrase = LuceneSearchService.escapeSearchTerm(phrase);
            phrase = schemaService.normalizeSearchTerm(phrase);
            String sQuery = "(type:\"workitem\" OR type:\"workitemarchive\") AND ($modelversion:businesspartner-*)";
            sQuery += " AND (" + phrase + "*)";

            logger.finest("SearchQuery= " + sQuery);

            searchResult = documentService.find(sQuery, MAX_SEARCH_RESULT, 0);
        } catch (Exception e) {
            logger.warning("  lucene error - " + e.getMessage());
        }

        // sort by txtname..
        Collections.sort(searchResult, new ItemCollectionComparator("$workflowsummary", true));
        return searchResult;
    }

    /**
     * Packt die Liste der Bank Details (ItemCollections) in ein Workitem
     * 
     * @param workitem
     */
    public static void implodeBanks(ItemCollection workitem, List<ItemCollection> ibanList) {
        List<Map> mapOrderItems = new ArrayList();
        if (ibanList != null) {
            logger.fine("Convert child items into Map...");
            Iterator<?> var3 = ibanList.iterator();

            while (var3.hasNext()) {
                ItemCollection orderItem = (ItemCollection) var3.next();
                mapOrderItems.add(orderItem.getAllItems());
            }

            workitem.replaceItemValue(BusinessPartnerService.ITEM_IBAN_LIST, mapOrderItems);
        }

    }

    /**
     * Enpackt die iban Map Liste von eiem Worktiem in eine Liste von ItemCollection
     * 
     * @param workitem
     */
    public static List<ItemCollection> explodeBanks(ItemCollection workitem) {
        List<ItemCollection> ibanList = new ArrayList();
        List<Object> mapOrderItems = workitem.getItemValue(BusinessPartnerService.ITEM_IBAN_LIST);
        Iterator<?> var4 = mapOrderItems.iterator();
        while (var4.hasNext()) {
            Object mapOderItem = var4.next();
            if (mapOderItem instanceof Map) {
                ItemCollection itemCol = new ItemCollection((Map) mapOderItem);

                ibanList.add(itemCol);

            }
        }
        return ibanList;
    }

    /**
     * Liefert die ChildItems mit den IBAN daten
     * 
     * @param workitem
     * @return
     */
    public static List<ItemCollection> getBanks(ItemCollection workitem) {
        List<ItemCollection> result = new ArrayList<>();
        List<Object> mapOrderItems = workitem.getItemValue(BusinessPartnerService.ITEM_IBAN_LIST);
        Iterator<?> var4 = mapOrderItems.iterator();
        while (var4.hasNext()) {
            Object mapOderItem = var4.next();
            if (mapOderItem instanceof Map) {
                ItemCollection itemCol = new ItemCollection((Map) mapOderItem);
                result.add(itemCol);
            }
        }
        return result;
    }

    /**
     * Diese Methode übertragt neue IBAN/BIC Pare in den Kreditor Banken Bereich
     * 
     * @param cdtrNumber
     * @param iban
     * @param bic
     * @throws PluginException
     */
    public void addNewIBANBIC(ItemCollection businessPartner, String iban, String bic) throws PluginException {
        if (businessPartner != null) {

            List<ItemCollection> bankenListe = explodeBanks(businessPartner);
            ItemCollection newbank = new ItemCollection();
            // {iban=[IBAN], name=[Test Bank], id=[test ], bic=[BIC]}
            newbank.setItemValue("iban", iban);
            newbank.setItemValue("bic", bic);
            newbank.setItemValue("id", bankenListe.size() + 1);
            newbank.setItemValue("name", "Bank-" + bankenListe.size() + 1);

            bankenListe.add(newbank);
            implodeBanks(businessPartner, bankenListe);

            documentService.save(businessPartner);

        }

    }

    /**
     * Diese Methode gibt true zurück wenn die angegebene IBAN/BIC Kombination als
     * bank bereits bekannt ist
     * 
     * @param cdtrNumber
     * @param iban
     * @param bic
     * @throws PluginException
     */
    public boolean isIBANBICKnown(ItemCollection businessPartner, String iban, String bic) throws PluginException {

        if (businessPartner != null) {

            List<ItemCollection> bankenListe = explodeBanks(businessPartner);
            for (ItemCollection bank : bankenListe) {
                if (iban.equals(bank.getItemValueString("iban"))
                        && bic.equals(bank.getItemValueString("bic"))) {
                    // known!
                    return true;
                }
            }
        }
        return false;

    }

}