/*******************************************************************************
 * Copyright (c) 2019 fortiss GmbH
 *               2020 Johannes Kepler University Linz
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Martin Jobst - initial API and implementation and/or initial documentation
 *   Alois Zoitl  - fixed adapter and fb number generation in connection lists
 *******************************************************************************/
package org.eclipse.fordiac.ide.export.forte_ng.composite

import java.nio.file.Path
import java.util.ArrayList
import java.util.HashSet
import org.eclipse.emf.common.util.EList
import org.eclipse.fordiac.ide.export.forte_ng.ForteFBTemplate
import org.eclipse.fordiac.ide.model.libraryElement.AdapterFB
import org.eclipse.fordiac.ide.model.libraryElement.AdapterFBType
import org.eclipse.fordiac.ide.model.libraryElement.CompositeFBType
import org.eclipse.fordiac.ide.model.libraryElement.Connection
import org.eclipse.fordiac.ide.model.libraryElement.DataConnection
import org.eclipse.fordiac.ide.model.libraryElement.EventConnection
import org.eclipse.fordiac.ide.model.libraryElement.FBNetworkElement
import org.eclipse.fordiac.ide.model.libraryElement.IInterfaceElement
import org.eclipse.fordiac.ide.model.libraryElement.VarDeclaration
import org.eclipse.xtend.lib.annotations.Accessors

class CompositeFBImplTemplate extends ForteFBTemplate {

	@Accessors(PROTECTED_GETTER) CompositeFBType type

	var fbs = new ArrayList<FBNetworkElement>
	var numCompFBParams = 0;
	var eConnNumber = 0
	var fannedOutEventConns = 0
	var dataConnNumber = 0
	var fannedOutDataConns = 0

	new(CompositeFBType type, String name, Path prefix) {
		super(name, prefix)
		this.type = type
		fbs.addAll(type.FBNetwork.networkElements.filter[!(it.type instanceof AdapterFBType)])
	}

	override generate() '''
		«generateHeader»

		«generateImplIncludes»

		«generateFBDefinition»

		«generateFBInterfaceDefinition»

		«generateFBInterfaceSpecDefinition»

		«generateFBNetwork»

	'''

	def protected generateFBNetwork() '''
		«IF type.FBNetwork.networkElements.exists[!(it.type instanceof AdapterFBType)]»
		const SCFB_FBInstanceData «FBClassName»::scm_astInternalFBs[] = {
		  «FOR elem : fbs SEPARATOR ",\n"»{«elem.name.FORTEString», «elem.type.name.FORTEString»}«ENDFOR»
		};
		«ENDIF»

		«type.FBNetwork.networkElements.exportFBParams»

		«IF !type.FBNetwork.eventConnections.empty»
		    «type.FBNetwork.eventConnections.exportEventConns»

		«ENDIF»
		«IF !type.FBNetwork.dataConnections.empty»
			«type.FBNetwork.dataConnections.exportDataConns»

		«ENDIF»
		«generateFBNDataStruct()»
		'''
	
	protected def generateFBNDataStruct()
		'''
		const SCFB_FBNData «FBClassName»::scm_stFBNData = {
		  «fbs.size», «IF !fbs.isEmpty»scm_astInternalFBs«ELSE»nullptr«ENDIF»,
		  «eConnNumber», «IF 0 != eConnNumber»scm_astEventConnections«ELSE»nullptr«ENDIF»,
		  «fannedOutEventConns», «IF 0 != fannedOutEventConns»scm_astFannedOutEventConnections«ELSE»nullptr«ENDIF»,
		  «dataConnNumber», «IF 0 != dataConnNumber»scm_astDataConnections«ELSE»nullptr«ENDIF»,
		  «fannedOutDataConns», «IF 0 != fannedOutDataConns»scm_astFannedOutDataConnections«ELSE»nullptr«ENDIF»,
		  «numCompFBParams», «IF 0 != numCompFBParams»scm_astParamters«ELSE»nullptr«ENDIF»
		};
		
		'''
	

	def protected generateConnectionPortID(IInterfaceElement iface, FBNetworkElement elem) {
		return if(type.FBNetwork.networkElements.contains(elem))
			'''GENERATE_CONNECTION_PORT_ID_2_ARG(«elem.name.FORTEString», «iface.name.FORTEString»), «elem.fbId»'''
		else
			'''GENERATE_CONNECTION_PORT_ID_1_ARG(«iface.name.FORTEString»), -1'''
	}

	def protected dispatch fbId(FBNetworkElement elem)
	   '''«fbs.indexOf(elem)»'''

	def protected dispatch fbId(AdapterFB elem)
	   '''CCompositeFB::scm_nAdapterMarker | «IF elem.isPlug»«getPlugIndex(elem)»«ELSE»«type.interfaceList.sockets.indexOf(elem.adapterDecl)»«ENDIF»'''

    def protected getPlugIndex(AdapterFB elem) {
        type.interfaceList.sockets.size + type.interfaceList.plugs.indexOf(elem.adapterDecl)
    }

    def protected exportEventConns(EList<EventConnection> eConns) {
        var retVal = new StringBuilder()
        var conSet = new HashSet()
        var fannedOutConns = new StringBuilder()

        retVal.append("const SCFB_FBConnectionData " + FBClassName + "::scm_astEventConnections[] = {\n")

        for (Connection eConn : eConns) {
            if (!conSet.contains(eConn)) {
                conSet.add(eConn)

                retVal.append(eConn.getConnListEntry)

                if (eConn.source.getOutputConnections.size > 1) {
                    // we have fan out
                    for (Connection fannedConn : eConn.source.getOutputConnections().filter[!(it == eConn)]) {
                        conSet.add(fannedConn)
                        fannedOutConns.append(fannedConn.genFannedOutConnString(eConnNumber))
                        fannedOutEventConns++
                    }
                }
                eConnNumber++;
            }
        }

        retVal.append("};\n")

        retVal.append("\nconst SCFB_FBFannedOutConnectionData " + FBClassName + "::scm_astFannedOutEventConnections[] = {\n")
        if (0 != fannedOutEventConns) {
            retVal.append(fannedOutConns)
        }
        retVal.append("};\n"); //$NON-NLS-1$
    }

    def protected exportDataConns(EList<DataConnection> dataConns) {
        var retVal = new StringBuilder()
        var conSet = new HashSet()
        var fannedOutConns = new StringBuilder()

        retVal.append("const SCFB_FBConnectionData " + FBClassName + "::scm_astDataConnections[] = {\n")

        for (DataConnection dConn : dataConns) {
            if (!conSet.contains(dConn)) {
                val primConn = getPrimaryDataConn(dConn)
                conSet.add(primConn);

                retVal.append(primConn.getConnListEntry)

                if (primConn.source.getOutputConnections.size > 1 ){
                    // we have fan out
                    for (Connection fannedConn : primConn.source.getOutputConnections().filter[!(it == primConn)]) {
                        conSet.add(fannedConn)
                        if (fannedConn.hasCFBInterfaceDestination && primConn.hasCFBInterfaceDestination){
                            fannedOutConns.append("#error a fanout to several composite FB's outputs is currently not supported: "); //$NON-NLS-1$
                            errors.add(" - " + name + " FORTE does currently not allow that a data a composite's data connection may be connected to several data outputs of the composite FB."); //$NON-NLS-1$
                        }
                        fannedOutConns.append(fannedConn.genFannedOutConnString(dataConnNumber))
                        fannedOutDataConns++
                    }
                }
                dataConnNumber++;
            }
        }

        retVal.append("};\n")

        retVal.append("\nconst SCFB_FBFannedOutConnectionData " + FBClassName + "::scm_astFannedOutDataConnections[] = {\n") 
        if (0 != fannedOutDataConns) {
            retVal.append(fannedOutConns)
        }
        retVal.append("};\n"); //$NON-NLS-1$
    }

    def protected getConnListEntry(Connection con)
    '''  {«con.source.generateConnectionPortID(con.sourceElement)», «con.destination.generateConnectionPortID(con.destinationElement)»},
    '''

    def protected genFannedOutConnString(Connection con, int connNum) {
        '''  {«connNum», «con.destination.generateConnectionPortID(con.destinationElement)»},
        '''
    }

    def private getPrimaryDataConn(DataConnection dataConn) {
        //if from the source one connection is target to the interface of the CFB we have to take this first
        for (Connection dc : dataConn.getSource().getOutputConnections()) {
            if (dc.hasCFBInterfaceDestination) {
                return dc
            }
        }
        return dataConn
    }

    def private hasCFBInterfaceDestination(Connection conn){
        conn?.getDestination()?.eContainer()?.eContainer() instanceof CompositeFBType
    }

	def protected exportFBParams(EList<FBNetworkElement> fbs) {
		var retVal = new StringBuilder()

		for (FBNetworkElement fb : fbs) {
			for (VarDeclaration v : fb.getInterface.getInputVars.filter[it.value !== null && !it.value.value.isEmpty]) {
				retVal.append('''  {«fb.fbId», g_nStringId«v.name», "«getParamValue(v)»"},
				''')
				numCompFBParams++
			}
		}

		'''
		const SCFB_FBParameter «FBClassName»::scm_astParamters[] = {
		«IF 0 != numCompFBParams»«retVal.toString»«ENDIF»
		};'''
	}
	
	def private getParamValue(VarDeclaration v) {
		v.value.value.replace("\"", "\\\"");
	}

}