import "Simantics/DB"
import "Simantics/Ontologies"
import "Simantics/Variables"
import "http://www.simantics.org/DistrictNetwork-1.0" as DN

import "Map" as Map
import "MSet" as MSet

importJava "org.simantics.district.network.DistrictNetworkUtil" where
    calculateDistance :: Resource -> Resource -> <ReadGraph> Double

importJava "org.simantics.district.network.ModelledCRS" where
    xToLongitude :: Double -> <Proc> Double
    yToLatitude :: Double -> <Proc> Double
    longitudeToX :: Double -> <Proc> Double
    latitudeToY :: Double -> <Proc> Double

findBrokenConnections :: Resource -> <ReadGraph, Proc> ()
findBrokenConnections diagram = do
    elements = objectsWithType diagram L0.ConsistsOf DIA.DefinedElement
    print $ "Found " + show (length elements) + " elements from diagram"
    symbols = MMap.create ()
    iter (\el -> do
        symbol = singleObject el L0.InstanceOf
        print $ "Found symbol " + uriOf symbol
        ccs = collectionToList $ objects_ symbol L0.ConsistsOf
        connectionPointRelations = filter (\cc -> isSubrelationOf cc  STR.IsConnectedTo) ccs
        print $ "Found " + show (length connectionPointRelations) + " cprs"
        iter (\cpr -> do
            connectionPoints = objectsWithType el cpr DIA.Connector
            print $ "Found " + show (length connectionPoints) + " cps"
            if length connectionPoints > 1 /*|| length connectionPoints == 0*/
            then do
                // get existing map
                print $ "Found " + show (length connectionPoints) + " connections for element " + nameOf el
                instances = match MMap.get symbols (uriOf symbol) with
                    Just m -> m
                    Nothing -> do
                        set = MSet.create ()
                        MMap.put symbols (uriOf symbol) set
                        set
                ignore $ MSet.add instances $ singleObject el MOD.ElementToComponent
            else ()
            ()
        ) connectionPointRelations
    ) elements
    MMap.iter (\key val -> do
        print key
        MSet.iter (\v -> print (nameOf v)) val
        ()
    ) symbols 
    ()

translateAllElements :: Resource -> <WriteGraph, Proc> ()
translateAllElements diagram = do
    print $ "Translating elements of diagram " + uriOf diagram 
    elements = objectsWithType diagram L0.ConsistsOf DIA.DefinedElement
    print $ "Found " + show (length elements) + " elements from diagram"
    iter (\el -> do
        connectionPoints = objectsWithType el STR.IsConnectedTo DIA.Connector
        print $ "Found " + show (length connectionPoints) + " connections for element " + nameOf el
    ) elements


translateElement :: Resource -> <WriteGraph, Proc> ()
translateElement elem = do
    connectionPoints = objectsWithType elem STR.IsConnectedTo DIA.Connector
    if length connectionPoints < 5
    then do //this we can handle
        areConnected = MSet.create ()
        iter (\cp -> do
            aconnector = singleObject cp  DIA.AreConnected
            //otherElem
            ()
        ) []
        //if length areConnected == 2
        //then do // this we can handle - only two symbols
        //    ()
        //else ()
        ()
    else ()
    ()

importJava "org.simantics.district.network.DistrictNetworkUtil" where
    createVertex :: Resource -> Vector Double -> Resource -> <WriteGraph, Proc> Resource
    createEdge :: Resource -> Resource -> <WriteGraph, Proc> Resource

"""
Tries to look for the Resource representing the configuration component
mapped to the specified district network diagram element.
"""
possibleMappedComponent :: Resource -> <ReadGraph> Maybe Resource
possibleMappedComponent r = match possibleObject r DN.MappedComponent with
    Nothing -> Nothing
    Just me -> possibleObject me MOD.ElementToComponent

"""
Tries to look for the Variable representing the configuration component
mapped to the specified district network diagram element.

The variable returned is by default the active experiment context variable
but if that is not available then a configuration context variable is returned.
"""
possibleMappedComponentVariable :: Resource -> <ReadGraph> Maybe Variable
possibleMappedComponentVariable r = match possibleMappedComponent r with
    Nothing -> Nothing
    Just mc -> do
        mcv = resourceVariable mc
        match possibleActiveVariable mcv with
            Nothing -> Just mcv
            a       -> a

"""
"""
possibleMappedComponentPropertyValue :: Serializable a => Typeable a => String -> Resource -> <ReadGraph> Maybe a
possibleMappedComponentPropertyValue propName r = match possibleMappedComponentVariable r with
    Nothing -> Nothing
    Just mv -> possiblePropertyValue mv propName

"""
"""
mappedComponentPropertyValue :: Serializable a => Typeable a => a -> String -> Resource -> <ReadGraph> a
mappedComponentPropertyValue def propName r = match possibleMappedComponentVariable r with
    Nothing -> def
    Just mv -> match possiblePropertyValue mv propName with
        Nothing -> def
        Just v  -> v

"""
Returns possible district network element that is mapped to the
specified model configuration component. The DN element is found
using the following relation path:

    domain model configuration component ---[MOD.ComponentToElement]---> domain model diagram element
                                         ----[DN.MappedFromElement]----> district network diagram element
"""
possibleDNElementMappedToComponent :: Resource -> <ReadGraph> Maybe Resource
possibleDNElementMappedToComponent mappedComponent = match possibleObject mappedComponent MOD.ComponentToElement with
    Nothing      -> Nothing
    Just element -> possibleObject element DN.MappedFromElement

"""
Returns all district network elements that are found to be mapped the
specified mapped model configuration components by
[possibleDNElementMappedToComponent](possibleDNElementMappedToComponent).

The result list can be smaller than the input resource list, even empty.
"""
dnElementsMappedToComponents :: [Resource] -> <ReadGraph> [Resource]
dnElementsMappedToComponents mappedComponents = mapMaybe possibleDNElementMappedToComponent mappedComponents