workspace {
    name "Soarse Platform"
    description "Enterprise Data Management Platform - Master Data Management System" 
    !impliedRelationships true

    configuration {
        visibility public
    }

    model {
        user = person "End User" "Business users managing master data, policies, and workflows" "User"
        admin = person "System Administrator" "System administrator managing users, authorities, and configurations" "Admin"
        externalAuthSystem = softwareSystem "External Authentication System" "External identity provider for SSO integration" "External"
        emailSystem = softwareSystem "Email System (Mailgun)" "SMTP email service for notifications and password resets" "External"


        soarseplatform = softwareSystem "Soarse Platform" {
            description "Enterprise platform for master data management, validation, policy enforcement, and workflow orchestration" 
            tags "Spring Cloud"

            frontend = container "Frontend Application" "Single Page Application providing user interface for all platform features" "React, TypeScript, Nginx" "Browser" {
                elementUI = component "Element Management UI" "User interface for MDM elements and entries" "React" "UI"
                identityUI = component "Identity Management UI" "User and authority management interface" "React" "UI"
                treeUI = component "Tree Visualization" "Hierarchical object tree visualization" "React, React Flow" "UI"
                policyUI = component "Policy Management UI" "ABAC policy configuration interface" "React" "UI"
                pipelineUI = component "Pipeline/BPMN Editor" "Business process designer" "React, BPMN.js" "UI"
                ontologyUI = component "Ontology Visualization" "Semantic relationships viewer" "React" "UI"
                formulaUI = component "Formula Editor" "Formula and metadata editor" "React, CodeMirror" "UI"
            }

            gateway = container "API Gateway" "Handles routing, authentication, and session management" "Spring Cloud Gateway, Java" "Tool, Spring Cloud" {
                routingEngine = component "Routing Engine" "Routes requests to appropriate backend services" "Spring Cloud Gateway"
                sessionManager = component "Session Manager" "Manages user sessions with Redis" "Spring Session"
                authFilter = component "Authentication Filter" "Validates user authentication" "Spring Security"
            }

            mdmService = container "MDM Service (Core)" "Master Data Management - manages reference data, dictionaries, and classifiers" "Spring Boot, jOOQ, Java" "Pillar, Spring" {
                elementController = component "Element Controller" "CRUD operations for elements (dictionaries)" "Spring MVC" "API"
                entryController = component "Entry Controller" "CRUD operations for entries (dictionary records)" "Spring MVC" "API"
                versionManager = component "Version Manager" "Manages element and entry versioning" "Spring Boot"
                deduplication = component "Deduplication Engine" "Identifies and manages duplicate entries" "Spring Boot"
                searchService = component "Full-Text Search" "Search engine for elements and entries" "Spring Boot"
                batchProcessor = component "Batch Processor" "Bulk import/export operations" "Spring Batch"
                treeSupplier = component "Tree Supplier" "Supplies element data to Tree service" "Spring Boot"
            }

            treeService = container "Tree Service" "Unified hierarchical object tree management and visualization" "Spring Boot, jOOQ, Java" "Addon, Spring" {
                treeNodeManager = component "Tree Node Manager" "Manages tree nodes and hierarchies" "Spring Boot"
                groupManager = component "Group Manager" "Manages groups and object collections" "Spring Boot"
                typeRegistry = component "Type Registry" "Registers and manages object types from different services" "Spring Boot"
                configManager = component "System Config Manager" "Stores and manages system-wide configuration" "Spring Boot"
                treeController = component "Tree Controller" "CRUD operations for tree nodes" "Spring MVC" "API"
            }

            identityService = container "Identity Service" "User identity, authentication, authorization, and organization management" "Spring Boot, Spring Security, Java" "Tool, Spring" {
                authController = component "Authentication Controller" "Handles login, logout, password reset" "Spring MVC" "API"
                userManager = component "User Manager" "User CRUD and profile management" "Spring Boot" "API"
                authorityManager = component "Authority Manager" "Role and permission management" "Spring Boot"
                orgManager = component "Organization Manager" "Organization structure management" "Spring Boot"
                externalAuthMapper = component "External Auth Mapper" "Maps external authentication to internal users" "Spring Boot"
                notificationService = component "Notification Service" "Sends email notifications" "Spring Mail"
            }

            validationService = container "Validation Service" "Data validation against JSON schemas and global type definitions" "Spring Boot, JSON Schema Validator, Java" "Addon, Spring" {
                validatorEngine = component "Validator Engine" "Validates data against JSON schemas" "JSON Schema Validator"
                globalTypeManager = component "Global Type Manager" "Manages global type definitions" "Spring Boot"
                schemaRegistry = component "Schema Registry" "Stores and retrieves schemas" "Spring Boot"
            }

            policyService = container "Policy Service (ABAC)" "Attribute-Based Access Control policy management and enforcement" "Spring Boot, jOOQ, Java" "Pillar, Spring" {
                policyController = component "Policy Controller" "Policy CRUD operations" "Spring MVC" "API"
                policyEvaluator = component "Policy Evaluator" "Evaluates policies for access decisions" "Spring Boot"
                attributeFetcher = component "Attribute Fetcher" "Fetches attributes from MDM, Tree, Metadata services" "OpenFeign"
            }

            metadataService = container "Metadata Service" "Metadata aggregation and formula evaluation across services" "Spring Boot, Java" "Pillar, Spring" {
                metadataAggregator = component "Metadata Aggregator" "Aggregates metadata from all services" "Spring Boot"
                formulaEngine = component "Formula Engine" "Evaluates formulas and expressions" "Spring Boot"
                metadataCollector = component "Metadata Collector" "Collects metadata via RabbitMQ" "Spring AMQP"
                metadataController = component "Schema CRUD" "CRUD operations for metadata and formulas" "Spring MVC" "API"
            }

            eventsService = container "Events Service" "Event logging, tracking, and audit trail across the platform" "Spring Boot, jOOQ, Java" "Tool, Spring" {
                eventLogger = component "Event Logger" "Logs events from all services" "Spring Boot"
                eventQuery = component "Event Query" "Queries event history" "Spring Boot"
                eventAggregator = component "Event Aggregator" "Aggregates events via RabbitMQ" "Spring AMQP"
            }

            fileService = container "File Service" "File upload, storage, and retrieval" "Spring Boot, Java" "Addon, Spring" {
                fileController = component "File Controller" "File upload/download API" "Spring MVC" "API"
                storageAdapter = component "Storage Adapter" "Interfaces with MinIO object storage" "MinIO SDK"
            }

            # Relations Service Container
            relationsService = container "Relations Service" "Semantic relationships and ontology management using RDF/SPARQL" "Spring Boot, Java" "Addon, Spring" {
                ontologyManager = component "Ontology Manager" "Manages ontologies and relationships" "Spring Boot"
                rdfAdapter = component "RDF Adapter" "Interfaces with Fuseki triple store" "Apache Jena"
                ontologySyncer = component "Ontology Syncer" "Syncs ontology classes from MDM" "Spring AMQP"
            }

            # Pipeline Service Container
            pipelineService = container "Pipeline Service" "Business process management and workflow orchestration" "Spring Boot, jOOQ, Java" "Addon, Spring" {
                processManager = component "Process Manager" "Manages process definitions" "Spring Boot"
                workflowEngine = component "Workflow Engine" "Executes BPMN workflows" "Spring Boot"
                processRegistry = component "Process Registry" "Registers processes with Tree service" "Spring Boot"
            }
            coreDB = container "Core Database" "Stores MDM elements, entries, and versions" "PostgreSQL" "Database, Postgres" 
            treeDB = container "Tree Database" "Stores tree nodes, groups, and system config" "PostgreSQL" "Database, Postgres" 
            identityDB = container "Identity Database" "Stores users, authorities, organizations" "PostgreSQL" "Database, Postgres" 
            validationDB = container "Validation Database" "Stores global type definitions" "PostgreSQL" "Database, Postgres" 
            policyDB = container "Policy Database" "Stores ABAC policies" "PostgreSQL" "Database, Postgres" 
            metadataDB = container "Metadata Database" "Stores aggregated metadata" "PostgreSQL" "Database, Postgres" 
            eventsDB = container "Events Database" "Stores event logs and audit trails" "PostgreSQL" "Database, Postgres" 
            fileDB = container "File Database" "Stores file metadata" "PostgreSQL" "Database, Postgres" 
            relationsDB = container "Relations Database" "Stores relationship metadata" "PostgreSQL" "Database, Postgres" 
            pipelineDB = container "Pipeline Database" "Stores process definitions and executions" "PostgreSQL" "Database, Postgres"
            redis = container "Redis" "In-memory cache for sessions and application data" "" "Database, Redis"
            fuseki = container "Apache Jena Fuseki" "RDF triple store for semantic data and SPARQL queries" "" "Database, Jena"


        }

        # Infrastructure Systems - Service Discovery & Messaging
        consul = softwareSystem "Consul" "Service discovery, registration, and distributed configuration management" "Tool, Consul"
        rabbitmq = softwareSystem "RabbitMQ" "Message broker for event-driven communication between services" "Tool, Queue, Rabbit"
        minio = softwareSystem "MinIO" "S3-compatible object storage for files" "Tool, Minio"

        # Infrastructure Systems - Monitoring & Observability
        adminServer = softwareSystem "Spring Boot Admin" "Centralized monitoring and management dashboard for all Spring Boot applications" "Infrastructure, Spring Cloud"
        zipkin = softwareSystem "Zipkin" "Distributed tracing system for tracking requests across microservices" "Infrastructure, Zipkin"
        prometheus = softwareSystem "Prometheus" "Metrics collection and time-series database" "Infrastructure, Prometheus"
        grafana = softwareSystem "Grafana" "Visualization and analytics platform for metrics and logs" "Infrastructure, Grafana"

        # Infrastructure Systems - Logging
        loki = softwareSystem "Loki" "Horizontally scalable, multi-tenant log aggregation system" "Infrastructure, Loki"
        promtail = softwareSystem "Promtail" "Log shipping agent that forwards logs to Loki" "Infrastructure, Loki"

        # User Relationships
        user -> frontend "Uses web browser to access"
        admin -> frontend "Manages system via web interface"

        # Frontend to Gateway
        frontend -> gateway "Makes API calls via HTTPS" "JSON/REST"
        elementUI -> gateway "MDM operations"
        identityUI -> gateway "Identity operations"
        treeUI -> gateway "Tree operations"
        policyUI -> gateway "Policy operations"
        pipelineUI -> gateway "Pipeline operations"
        ontologyUI -> gateway "Relations operations"
        formulaUI -> gateway "Metadata operations"

        # Gateway to Services
        gateway -> elementController "Routes MDM requests" "HTTP/REST" "Synchronous"
        gateway -> entryController "Routes MDM requests" "HTTP/REST" "Synchronous"
        gateway -> treeController "Routes Tree requests" "HTTP/REST"
        gateway -> authController "Routes Identity requests" "HTTP/REST"
        gateway -> validationService "Routes Validation requests" "HTTP/REST"
        gateway -> policyController "Routes Policy requests" "HTTP/REST"
        gateway -> metadataController "Routes Metadata requests" "HTTP/REST"
        gateway -> eventsService "Routes Events requests" "HTTP/REST"
        gateway -> fileController "Routes File requests" "HTTP/REST"
        gateway -> relationsService "Routes Relations requests" "HTTP/REST"
        gateway -> pipelineService "Routes Pipeline requests" "HTTP/REST"

        # Gateway Infrastructure
        routingEngine -> sessionManager "Manages sessions"
        sessionManager -> redis "Stores sessions" "Redis Protocol"
        authFilter -> identityService "Validates authentication"

        # Service to Service Relationships
        mdmService -> validationService "Validates data against schemas" "HTTP/REST"
        mdmService -> relationsService "Creates semantic relationships" "RabbitMQ" "Asynchronous"
        mdmService -> eventsService "Logs events" "RabbitMQ""Asynchronous"

        treeService -> treeSupplier "Fetches element data" "HTTP/REST"
        treeService -> pipelineService "Fetches process data" "HTTP/REST"
        treeService -> eventsService "Logs events" "RabbitMQ""Asynchronous"

        identityService -> eventsService "Logs authentication events" "RabbitMQ" "Asynchronous"
        identityService -> emailSystem "Sends email notifications" "SMTP"
        identityService -> externalAuthSystem "Integrates external authentication" "OAuth/SAML"

        attributeFetcher -> entryController "Fetches attributes for policy evaluation" "HTTP/REST"
        attributeFetcher -> treeController "Fetches context data" "HTTP/REST"
        attributeFetcher -> metadataController "Fetches metadata attributes" "HTTP/REST"

        metadataAggregator -> elementController "Collects MDM metadata" "RabbitMQ" "Asynchronous"
        metadataAggregator -> treeController "Collects Tree metadata" "RabbitMQ" "Asynchronous"
        metadataAggregator -> userManager "Collects Identity metadata" "RabbitMQ" "Asynchronous"

        rdfAdapter -> fuseki "Stores/queries RDF triples" "SPARQL/HTTP"

        storageAdapter -> minio "Stores/retrieves files" "S3 API"

        processRegistry -> typeRegistry "Registers process types" "HTTP/REST"

        # Service to Database
        mdmService -> coreDB "Reads/writes MDM data" "JDBC"
        treeService -> treeDB "Reads/writes tree data" "JDBC"
        identityService -> identityDB "Reads/writes identity data" "JDBC"
        validationService -> validationDB "Reads/writes type definitions" "JDBC"
        policyService -> policyDB "Reads/writes policies" "JDBC"
        metadataService -> metadataDB "Reads/writes metadata" "JDBC"
        eventsService -> eventsDB "Reads/writes events" "JDBC"
        fileService -> fileDB "Reads/writes file metadata" "JDBC"
        relationsService -> relationsDB "Reads/writes relation metadata" "JDBC"
        pipelineService -> pipelineDB "Reads/writes process data" "JDBC"

        # Component Level - MDM Service
        elementController -> versionManager "Manages versions"
        entryController -> versionManager "Manages versions"
        elementController -> searchService "Indexes elements"
        entryController -> deduplication "Checks duplicates"
        batchProcessor -> elementController "Bulk operations"
        treeSupplier -> elementController "Fetches element data"

        # Component Level - Tree Service
        treeNodeManager -> typeRegistry "Registers node types"
        groupManager -> treeNodeManager "Organizes nodes"

        # Component Level - Identity Service
        authController -> userManager "Authenticates users"
        authController -> notificationService "Sends password reset emails"
        userManager -> authorityManager "Assigns authorities"
        userManager -> orgManager "Assigns organizations"
        externalAuthMapper -> authController "Maps external users"

        # Component Level - Policy Service
        policyController -> policyEvaluator "Evaluates policies"
        policyEvaluator -> attributeFetcher "Fetches attributes"

        # Component Level - Relations Service
        ontologyManager -> rdfAdapter "Stores RDF"
        ontologySyncer -> ontologyManager "Syncs ontology classes"

        # Component Level - Pipeline Service
        processManager -> workflowEngine "Executes workflows"
        processManager -> processRegistry "Registers with Tree"

        # Service Discovery
        gateway -> consul "Discovers services" "HTTP" "Operational"
        mdmService -> consul "Registers service" "HTTP" "Operational"
        treeService -> consul "Registers service" "HTTP" "Operational"
        identityService -> consul "Registers service" "HTTP" "Operational"
        validationService -> consul "Registers service" "HTTP" "Operational"
        policyService -> consul "Registers service" "HTTP" "Operational"
        metadataService -> consul "Registers service" "HTTP" "Operational"
        eventsService -> consul "Registers service" "HTTP" "Operational"
        fileService -> consul "Registers service" "HTTP" "Operational"
        relationsService -> consul "Registers service" "HTTP" "Operational"
        pipelineService -> consul "Registers service" "HTTP" "Operational"

        # Message Broker Relationships
        mdmService -> rabbitmq "Publishes events" "AMQP" "Asynchronous"
        treeService -> rabbitmq "Publishes events" "AMQP" "Asynchronous"
        identityService -> rabbitmq "Publishes events" "AMQP" "Asynchronous"
        policyService -> rabbitmq "Publishes events" "AMQP" "Asynchronous"
        metadataService -> rabbitmq "Consumes metadata events" "AMQP" "Asynchronous"
        eventsService -> rabbitmq "Consumes all events" "AMQP" "Asynchronous"
        relationsService -> rabbitmq "Consumes relation events" "AMQP" "Asynchronous"

        # Configuration Management Relationships (Consul provides distributed configuration)
        gateway -> consul "Fetches configuration" "HTTP/REST" "Operational"
        mdmService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        treeService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        identityService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        validationService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        policyService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        metadataService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        eventsService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        fileService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        relationsService -> consul "Fetches configuration" "HTTP/REST" "Operational"
        pipelineService -> consul "Fetches configuration" "HTTP/REST" "Operational"

        # Spring Boot Admin Relationships
        gateway -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        mdmService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        treeService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        identityService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        validationService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        policyService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        metadataService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        eventsService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        fileService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        relationsService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"
        pipelineService -> adminServer "Registers and reports health" "HTTP/REST" "Operational"

        # Distributed Tracing Relationships
        gateway -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        mdmService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        treeService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        identityService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        validationService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        policyService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        metadataService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        eventsService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        fileService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        relationsService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"
        pipelineService -> zipkin "Sends trace data" "HTTP/REST" "Asynchronous"

        # Metrics Collection Relationships
        gateway -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        mdmService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        treeService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        identityService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        validationService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        policyService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        metadataService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        eventsService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        fileService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        relationsService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        pipelineService -> prometheus "Exposes metrics endpoint" "HTTP/Prometheus" "Operational"
        rabbitmq -> prometheus "Exposes metrics" "HTTP/Prometheus" "Operational"
        redis -> prometheus "Exposes metrics" "HTTP/Prometheus" "Operational"
        consul -> prometheus "Exposes metrics" "HTTP/Prometheus" "Operational"

        # Logging Relationships
        gateway -> promtail "Sends logs" "File/Stream" "Operational"
        mdmService -> promtail "Sends logs" "File/Stream" "Operational"
        treeService -> promtail "Sends logs" "File/Stream" "Operational"
        identityService -> promtail "Sends logs" "File/Stream" "Operational"
        validationService -> promtail "Sends logs" "File/Stream" "Operational"
        policyService -> promtail "Sends logs" "File/Stream" "Operational"
        metadataService -> promtail "Sends logs" "File/Stream" "Operational"
        eventsService -> promtail "Sends logs" "File/Stream" "Operational"
        fileService -> promtail "Sends logs" "File/Stream" "Operational"
        relationsService -> promtail "Sends logs" "File/Stream" "Operational"
        pipelineService -> promtail "Sends logs" "File/Stream" "Operational"
        promtail -> loki "Forwards logs" "HTTP/gRPC" "Asynchronous"

        # Observability Platform Relationships
        admin -> adminServer "Views application health and metrics" 
        admin -> grafana "Views dashboards and metrics"
        admin -> zipkin "Views distributed traces"
        grafana -> prometheus "Queries metrics" "PromQL/HTTP"
        grafana -> loki "Queries logs" "LogQL/HTTP"
        grafana -> zipkin "Queries traces" "HTTP/REST"

        # Deployment Environment
        deploymentEnvironment "Production" {
            deploymentNode "Kubernetes Cluster" "" "Kubernetes" {
                deploymentNode "Ingress" "" "Nginx Ingress Controller" {
                    deploymentNode "Frontend Pod" "" "Nginx" {
                        containerInstance frontend
                    }
                }

                deploymentNode "Gateway Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Gateway Pod" "" "JVM" {
                        containerInstance gateway
                    }
                }

                deploymentNode "MDM Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "MDM Pod" "" "JVM" {
                        containerInstance mdmService
                    }
                }

                deploymentNode "Tree Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Tree Pod" "" "JVM" {
                        containerInstance treeService
                    }
                }

                deploymentNode "Identity Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Identity Pod" "" "JVM" {
                        containerInstance identityService
                    }
                }

                deploymentNode "Validation Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Validation Pod" "" "JVM" {
                        containerInstance validationService
                    }
                }

                deploymentNode "Policy Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Policy Pod" "" "JVM" {
                        containerInstance policyService
                    }
                }

                deploymentNode "Metadata Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Metadata Pod" "" "JVM" {
                        containerInstance metadataService
                    }
                }

                deploymentNode "Events Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Events Pod" "" "JVM" {
                        containerInstance eventsService
                    }
                }

                deploymentNode "File Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "File Pod" "" "JVM" {
                        containerInstance fileService
                    }
                }

                deploymentNode "Relations Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Relations Pod" "" "JVM" {
                        containerInstance relationsService
                    }
                }

                deploymentNode "Pipeline Service Pods" "" "Kubernetes Deployment" {
                    deploymentNode "Pipeline Pod" "" "JVM" {
                        containerInstance pipelineService
                    }
                }

                deploymentNode "Consul StatefulSet" "" "Kubernetes StatefulSet" {
                    softwareSystemInstance consul
                }

                deploymentNode "RabbitMQ StatefulSet" "" "Kubernetes StatefulSet" {
                    softwareSystemInstance rabbitmq
                }

                deploymentNode "Redis StatefulSet" "" "Kubernetes StatefulSet" {
                    containerInstance redis
                }

                deploymentNode "MinIO StatefulSet" "" "Kubernetes StatefulSet" {
                    softwareSystemInstance minio
                }

                deploymentNode "Fuseki StatefulSet" "" "Kubernetes StatefulSet" {
                    containerInstance fuseki
                }

                deploymentNode "Spring Boot Admin Deployment" "" "Kubernetes Deployment" {
                    deploymentNode "Admin Server Pod" "" "JVM" {
                        softwareSystemInstance adminServer
                    }
                }

                deploymentNode "Zipkin Deployment" "" "Kubernetes Deployment" {
                    softwareSystemInstance zipkin
                }

                deploymentNode "Prometheus StatefulSet" "" "Kubernetes StatefulSet" {
                    softwareSystemInstance prometheus
                }

                deploymentNode "Loki StatefulSet" "" "Kubernetes StatefulSet" {
                    softwareSystemInstance loki
                }

                deploymentNode "Promtail DaemonSet" "" "Kubernetes DaemonSet" {
                    softwareSystemInstance promtail
                }

                deploymentNode "Grafana Deployment" "" "Kubernetes Deployment" {
                    softwareSystemInstance grafana
                }
            }
        }
    }

    views {
        theme https://structurizr.moarse.ru/workspace/1/theme

        branding {            
            logo soarse-logo.png
        }
        properties {
            "structurizr.timezone" "Europe/Moscow"
            "structurizr.locale" "ru-RU"
        }


        # Container View - Overall Architecture
        container soarseplatform "Containers" {
            include *
            exclude "element.tag==Database"
            exclude "element.tag==Infrastructure"
            exclude "relationship.tag==Asynchronous"
            exclude consul rabbitmq
        }

        # Container View - Frontend and Gateway
        container soarseplatform "FrontendGateway" {
            include user admin frontend gateway redis consul
            autoLayout lr
        }

        # Container View - Core Services
        container soarseplatform "CoreServices" {
           include gateway mdmService treeService validationService metadataService
        }

        # Container View - Supporting Services
        // container soarseplatform "SupportingServices" {
        //     include gateway metadataService eventsService fileService relationsService pipelineService metadataDB eventsDB fileDB relationsDB pipelineDB minio fuseki rabbitmq
        //     autoLayout lr
        // }

        # Component View - MDM Service
        component mdmService "MDMComponents" {
            include *
            autoLayout lr
        }

        # Component View - Tree Service
        component treeService "TreeComponents" {
            include *
            autoLayout lr
        }

        # Component View - Identity Service
        component identityService "IdentityComponents" {
            include *
        }

        # Component View - Gateway
        component gateway "GatewayComponents" {
            include *
            autoLayout lr
        }

        # Component View - Policy Service
        component policyService "PolicyComponents" {
            include *
            autoLayout lr
        }

        # Component View - Relations Service
        component relationsService "RelationsComponents" {
            include *
            autoLayout lr
        }

        # Component View - Frontend
        component frontend "FrontendComponents" {
            include *
        }

        # Infrastructure View - Configuration & Service Discovery
        // container soarseplatform "Infrastructure" {
        //     include consul adminServer redis
        //     include gateway mdmService treeService identityService validationService policyService metadataService eventsService fileService relationsService pipelineService
        //     autoLayout lr
        // }

        // # Infrastructure View - Observability Stack
        // container soarseplatform "Observability" {
        //     include zipkin prometheus grafana loki promtail
        //     include gateway mdmService treeService identityService validationService policyService metadataService eventsService fileService relationsService pipelineService
        //     autoLayout lr
        // }

        # System Landscape - All Infrastructure
        systemLandscape "SystemLandscape" {
            include *
        }

        # Deployment View
        // deployment soarseplatform "Production" "ProductionDeployment" {
        //     include *
        //     autoLayout lr
        // }

        # Dynamic View - User Authentication Flow
        dynamic soarseplatform "UserAuthentication" "User authentication flow" {
            user -> frontend "Access application"
            frontend -> gateway "Login request"
            gateway -> identityService "Authenticate"
            identityService -> identityDB "Verify credentials"
            identityDB -> identityService "User data"
            identityService -> gateway "Authentication token"
            gateway -> redis "Store session"
            gateway -> frontend "Session cookie"
            frontend -> user "Display dashboard"
            autoLayout lr
        }

        # Dynamic View - MDM Element Creation
        dynamic soarseplatform "MDMElementCreation" "Creating a new MDM element" {
            user -> frontend "Create element"
            frontend -> gateway "POST /api/v1/mdm/elements"
            gateway -> mdmService "Create element"
            mdmService -> validationService "Validate schema"
            validationService -> mdmService "Schema valid"
            mdmService -> coreDB "Insert element"
            mdmService -> rabbitmq " Publish create-relations event"
            rabbitmq -> relationsService "Create ontology"
            relationsService -> fuseki " Store RDF"
            mdmService -> treeService "Register in tree"
            treeService -> treeDB "Create tree node"
            mdmService -> eventsService "Log event"
            mdmService -> gateway "Element created"
            gateway -> frontend "Success response"
            autoLayout lr
        }

        # Dynamic View - Policy Evaluation
        dynamic soarseplatform "PolicyEvaluation" "Evaluating ABAC policy for access control" {
            user -> frontend " Request access to resource"
            frontend -> gateway "Access request"
            gateway -> policyService "Evaluate policy"
            policyService -> policyDB "Fetch policies"
            policyService -> mdmService "Fetch resource attributes"
            policyService -> treeService "Fetch context data"
            policyService -> metadataService "Fetch metadata"
            policyService -> gateway "Access decision"
            gateway -> mdmService "Execute operation (if allowed)"
            mdmService -> gateway "Result"
            gateway -> frontend "Response"
            autoLayout lr
        }


        themes default
    }

    configuration {
        scope softwaresystem
    }
}