workspace extends ../common/moderation-common-model.dsl {
    name "Snapshot system"
    description "Snapshot system is responsible for gathering snapshots from live streams by request"
    !identifiers hierarchical

    model {

        finOpsSystem = softwareSystem "FinOPS system" {
            tags "FinanceDomain" "FinOPS"

            identityvalidator = container "Identity validator" {
                tags "Google Cloud Platform - Kubernetes Engine" "FinanceDomain" "FinOPS"
                technology "Java"
            }
        }

        !extend mainKafkaCluster {

            streamFaceCaptureProcessingTopic = container "Stream face capture processing topic" {
                tags "Kafka" "Topic"
                technology "Kafka topic"
                description "Contains stream face capture internal command event=s"
            }
        }

        !extend snapshotSystem {
            snapshotKv = container "SnapshotKV" {
                description "Snapshot service state storage"
                technology "Aerospike" 
                tags "Google Cloud Platform - Compute Engine" "Database" "Aerospike" 

                snapshotSystem.snapshotService -> this "Read/write snapshot data" "Aerospike client"
            }

            streamFaceCaptureKV = container "StreamFaceCaptureKV" {
                description "Stream face capture storage"
                technology "Aerospike" 
                tags "Google Cloud Platform - Compute Engine" "Database" "Aerospike" 

                snapshotSystem.streamFaceCapture -> this "Read/write stream face capture data" "Aerospike client"
            }

        }

        !extend snapshotSystem.snapshotService {
            requestKTable = component "Snapshot request KTable" {
                description "Snapshot request KTable"
                technology "KTable"
                tags "KTable"

                mainKafkaCluster.snapshotRequestTopic -> this "Provide snapshot requests"
            }

            streamStateDao = component "Stream state DAO" {
                description "Stream state repository"

                -> snapshotKv "Read/Write stream state" "Aerospike client"
            }

            snapshotMetadataDao = component "Snapshot metadata DAO" {
                description "Snapshot metadata repository"

                -> snapshotKv "Read/Write snapshot metadata"
            }

            snapshotEngine = component "Snapshot engine" {
                description "Snapshot engine with throttling support"

                -> mainKafkaCluster.pushTopic "Send push for snapshot" "Kafka"
                -> snapshotMetadataDao "Read snapshot metadata"
                -> snapshotMetadataDao "Write snapshot metadata"
                -> streamStateDao "Get user's stream states"
                -> mainKafkaCluster.snapshotResponseTopic "Send snapshot response" "Kafka"
            }

            snapshotRequestKafkaListener = component "Snapshot request Kafka listener" {
                description "Snapshot request Kafka listener"
                technology "Kafka client"

                mainKafkaCluster.snapshotRequestTopic -> this "Consume snapshot requests"
                -> snapshotEngine "Request user snapshot" "Java"
            }

            streamSignalingStateKafkaListener = component "Stream signaling Kafka listener" {
                technology "Kafka client"

                mainKafkaCluster.streamSignalingStateTopic -> this "Provide stream states"
                -> streamStateDao "Store user streams data" "Java"
            }

            snapshotRequestWatchDog = component "Snapshot request watchdog" {
                description "Snapshot request Kafka listener"
                technology "Kafka client"

                -> requestKTable "Get partitioned requests" "Java"
                -> requestKTable "Delete request by TTL (tombstone)" "Kafka"
                -> snapshotEngine "Trigger snapshot response timeout" "Java"
            }

            api = component "API" {
                description "Snapshot request service API"
                technology "Spring"
                tags "API" 

                streamer -> this "Store snapshot metadata" "HTTPS"
                -> snapshotEngine "Store snapshot metadata" "Java"
            }
        }

        !extend snapshotSystem.streamFaceCapture {

            faceDao = component "Face DAO" {
                description "Face repository"

                -> streamFaceCaptureKV "Read/Write face state" "Aerospike client"
            }

            faceRecognition = component "Face recognition" {
                description "Banuba face recognition"
                technology "Python"
            }

            streamSignalingStateKafkaListener = component "Stream signaling Kafka listener" {
                technology "Kafka client"

                mainKafkaCluster.streamSignalingStateTopic -> this "Provide stream states"
                -> mainKafkaCluster.streamFaceCaptureProcessingTopic "Trigger snapshot" "Kafka"
            }

            snapshotResultKafkaListener = component "Snapshot response Kafka listener" {
                technology "Kafka client"

                mainKafkaCluster.snapshotResponseTopic -> this "Provide snapshot responses" "Kafka"
                -> mainKafkaCluster.streamFaceCaptureProcessingTopic "Trigger snapshot processing" "Kafka"
            }

            internalProcessingListener = component "Stream face capture internal processing listener" {
                technology "Kafka client"

                mainKafkaCluster.streamFaceCaptureProcessingTopic -> this "Process internal events" "Kafka"

                -> mainKafkaCluster.snapshotRequestTopic "Request snapshot" "Kafka"

                -> videoSystem.kino "Get stream screenshots" "HTTP"

                -> faceRecognition "Recognize faces" "HTTP"

                -> faceDao "Store best results" "HTTP"

                -> contentSystem.contentServer "Upload face screenshots" "HTTPS"
            }

            api = component "API" {
                description "Stream face capture API"
                technology "Spring"
                tags "API" 

                finOpsSystem.identityvalidator -> this "Ger best face image" "HTTPS"
                -> faceDao "Ger best face image" "Java"
            }
        }
    }

    views {

        systemLandscape "SystemLandscape" "Snapshot system landscape" {
            include *
            autoLayout
        }

        systemContext snapshotSystem "snapshotSystemContext" {
            include *
            autoLayout
        }

        container snapshotSystem "snapshotSystemContainer" {
            include *
            autoLayout
        }

        component snapshotSystem.snapshotService "snapshotServiceComponent" {
            include *
            autoLayout
        }


        component snapshotSystem.streamFaceCapture "streamFaceCaptureComponent" {
            include *
            autoLayout
        }

        dynamic snapshotSystem "request-user-snapshot-flow" {
            
            title "Request user snapshot flow"
            description "Describes steps to get user snapshot"

            streamSystem.streamSignaling -> mainKafkaCluster.streamSignalingStateTopic
            {
                {
                    mainKafkaCluster.streamSignalingStateTopic -> moderationSystem.moderationStream
                }
                {
                    mainKafkaCluster.streamSignalingStateTopic -> snapshotSystem.snapshotService
                }
            }
            moderationSystem.moderationStream -> mainKafkaCluster.snapshotRequestTopic
            mainKafkaCluster.snapshotRequestTopic -> snapshotSystem.snapshotService
            snapshotSystem.snapshotService -> userSystem.userinfo
            snapshotSystem.snapshotService -> mainKafkaCluster.pushTopic
            mainKafkaCluster.pushTopic -> notificationSystem.pushdelivery
            notificationSystem.pushdelivery -> streamer
            streamer -> contentSystem.contentServer "Upload snapshot" "HTTPS"
            streamer -> snapshotSystem.snapshotService
            snapshotSystem.snapshotService -> mainKafkaCluster.snapshotResponseTopic
            mainKafkaCluster.snapshotResponseTopic -> moderationSystem.moderationStream
            
        }

        dynamic snapshotSystem.streamFaceCapture "stream-face-capture-flow-kino" {
            title "Request the best streamer face screenshot via Kino service"
            description "Describes steps to get the best streamer face screenshot"

            streamSystem.streamSignaling -> mainKafkaCluster.streamSignalingStateTopic
            mainKafkaCluster.streamSignalingStateTopic -> snapshotSystem.streamFaceCapture.streamSignalingStateKafkaListener
            snapshotSystem.streamFaceCapture.streamSignalingStateKafkaListener -> mainKafkaCluster.streamFaceCaptureProcessingTopic
            mainKafkaCluster.streamFaceCaptureProcessingTopic -> snapshotSystem.streamFaceCapture.internalProcessingListener

            snapshotSystem.streamFaceCapture.internalProcessingListener -> videoSystem.kino
            
            snapshotSystem.streamFaceCapture.internalProcessingListener -> snapshotSystem.streamFaceCapture.faceRecognition
            snapshotSystem.streamFaceCapture.internalProcessingListener -> contentSystem.contentServer
            snapshotSystem.streamFaceCapture.internalProcessingListener -> snapshotSystem.streamFaceCapture.faceDao
            snapshotSystem.streamFaceCapture.faceDao -> snapshotSystem.streamFaceCaptureKV "Store best screenshot" "Aerospike client"

            finOpsSystem.identityvalidator -> snapshotSystem.streamFaceCapture.api
            snapshotSystem.streamFaceCapture.api -> snapshotSystem.streamFaceCapture.faceDao
            snapshotSystem.streamFaceCapture.faceDao -> snapshotSystem.streamFaceCaptureKV "Get best screenshot" "Aerospike client"
        }

        dynamic snapshotSystem.streamFaceCapture "stream-face-capture-flow-snapshot-service" {
            title "Request the best streamer face screenshot via snapshot service"
            description "Describes steps to get the best streamer face screenshot"

            streamSystem.streamSignaling -> mainKafkaCluster.streamSignalingStateTopic
            mainKafkaCluster.streamSignalingStateTopic -> snapshotSystem.streamFaceCapture.streamSignalingStateKafkaListener
            snapshotSystem.streamFaceCapture.streamSignalingStateKafkaListener -> mainKafkaCluster.streamFaceCaptureProcessingTopic
            mainKafkaCluster.streamFaceCaptureProcessingTopic -> snapshotSystem.streamFaceCapture.internalProcessingListener

            snapshotSystem.streamFaceCapture.internalProcessingListener -> mainKafkaCluster.snapshotRequestTopic

            mainKafkaCluster.snapshotResponseTopic -> snapshotSystem.streamFaceCapture.snapshotResultKafkaListener
            snapshotSystem.streamFaceCapture.snapshotResultKafkaListener -> mainKafkaCluster.streamFaceCaptureProcessingTopic
            mainKafkaCluster.streamFaceCaptureProcessingTopic -> snapshotSystem.streamFaceCapture.internalProcessingListener
            
            snapshotSystem.streamFaceCapture.internalProcessingListener -> snapshotSystem.streamFaceCapture.faceRecognition
            snapshotSystem.streamFaceCapture.internalProcessingListener -> contentSystem.contentServer
            snapshotSystem.streamFaceCapture.internalProcessingListener -> snapshotSystem.streamFaceCapture.faceDao
            snapshotSystem.streamFaceCapture.faceDao -> snapshotSystem.streamFaceCaptureKV "Store best screenshot" "Aerospike client"

            finOpsSystem.identityvalidator -> snapshotSystem.streamFaceCapture.api
            snapshotSystem.streamFaceCapture.api -> snapshotSystem.streamFaceCapture.faceDao
            snapshotSystem.streamFaceCapture.faceDao -> snapshotSystem.streamFaceCaptureKV "Get best screenshot" "Aerospike client"
        }
    }

}