services:
  # MySQL service
  mysql:
    image: mysql:8.0
    container_name: openisle-mysql
    restart: always
    env_file:
      - ../.env
    command: >
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_0900_ai_ci
      --default-time-zone=+08:00
      --skip-character-set-client-handshake
    ports:
      - "${MYSQL_PORT:-3306}:3306"
    volumes:
      - mysql-data:/var/lib/mysql
      - ../backend/src/main/resources/db/init:/docker-entrypoint-initdb.d:ro
      - ./mysql/conf.d:/etc/mysql/conf.d:ro
    networks:
      - openisle-network
    healthcheck:
      test: ["CMD","mysqladmin","ping","-h","127.0.0.1","-u","root","-p$MYSQL_ROOT_PASSWORD"]
      interval: 5s
      timeout: 3s
      retries: 30
      start_period: 20s


  # OpenSearch Service
  opensearch:
    build:
      context: .
      dockerfile: opensearch.Dockerfile
    container_name: opensearch
    environment:
      - cluster.name=os-single
      - node.name=os-node-1
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g
      - DISABLE_SECURITY_PLUGIN=true
      - cluster.blocks.create_index=false
    ulimits:
      memlock: { soft: -1, hard: -1 }
      nofile: { soft: 65536, hard: 65536 }
    volumes:
      - ./data:/usr/share/opensearch/data
      - ./snapshots:/snapshots
    ports:
      - "${OPENSEARCH_PORT:-9200}:9200"
      - "${OPENSEARCH_METRICS_PORT:-9600}:9600"
    restart: unless-stopped
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -fsS http://127.0.0.1:9200/_cluster/health >/dev/null",
        ]
      interval: 10s
      timeout: 5s
      retries: 30
      start_period: 60s
    networks:
      - openisle-network

  dashboards:
    image: opensearchproject/opensearch-dashboards:3.0.0
    container_name: os-dashboards
    environment:
      - OPENSEARCH_HOSTS=["http://opensearch:9200"]
      - DISABLE_SECURITY_DASHBOARDS_PLUGIN=true
    ports:
      - "${OPENSEARCH_DASHBOARDS_PORT:-5601}:5601"
    depends_on:
      - opensearch
    restart: unless-stopped
    networks:
      - openisle-network

  rabbitmq:
    image: rabbitmq:3.13-management
    container_name: openisle-rabbitmq
    restart: unless-stopped
    environment:
      RABBITMQ_DEFAULT_VHOST: ${RABBITMQ_VHOST:-/}
    ports:
      - "${RABBITMQ_PORT:-5672}:5672"
      - "${RABBITMQ_MANAGEMENT_PORT:-15672}:15672"
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
      - ./rabbitmq/conf/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf:ro
      - ./rabbitmq/conf/enabled_plugins:/etc/rabbitmq/enabled_plugins:ro
      - ./rabbitmq/definitions.json:/etc/rabbitmq/definitions.json:ro
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 10s
      timeout: 5s
      retries: 30
      start_period: 30s
    networks:
      - openisle-network

  redis:
    image: redis:7
    container_name: openisle-redis
    restart: unless-stopped
    env_file:
      - ../.env
    ports:
      - "${REDIS_PORT:-6379}:6379"
    volumes:
      - redis-data:/data
    networks:
      - openisle-network

  # Java spring boot service
  springboot:
    image: maven:3.9-eclipse-temurin-17
    container_name: openisle-springboot
    working_dir: /app
    env_file:
      - ../.env
    environment:
      SPRING_HEALTH_PATH: ${SPRING_HEALTH_PATH:-/actuator/health}
      SERVER_PORT: ${SERVER_PORT:-8080}
    ports:
      - "${SERVER_PORT:-8080}:${SERVER_PORT:-8080}"
    volumes:
      - ../backend:/app
      - maven-repo:/root/.m2
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_started
      rabbitmq:
        condition: service_started
      websocket-service:
        condition: service_healthy
      opensearch:
        condition: service_healthy
    command: >
      sh -c "apt-get update && apt-get install -y --no-install-recommends curl &&
             mvn clean spring-boot:run -Dmaven.test.skip=true"
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -fsS http://127.0.0.1:${SERVER_PORT:-8080}${SPRING_HEALTH_PATH:-/actuator/health} || exit 1",
        ]
      interval: 10s
      timeout: 5s
      retries: 30
      start_period: 60s
    networks:
      - openisle-network

  websocket-service:
    image: maven:3.9-eclipse-temurin-17
    container_name: openisle-websocket
    working_dir: /app
    env_file:
      - ../.env
    environment:
      WS_HEALTH_PATH: ${WS_HEALTH_PATH:-/actuator/health}
      WEBSOCKET_PORT: ${WEBSOCKET_PORT:-8082}
      SERVER_PORT: ${WEBSOCKET_PORT:-8082}
    ports:
      - "${WEBSOCKET_PORT:-8082}:${WEBSOCKET_PORT:-8082}"
    volumes:
      - ../websocket_service:/app
      - websocket-maven-repo:/root/.m2
    depends_on:
      rabbitmq:
        condition: service_healthy
    command: >
      sh -c "apt-get update && apt-get install -y --no-install-recommends curl &&
             mvn clean spring-boot:run -Dmaven.test.skip=true"
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -fsS http://127.0.0.1:${WEBSOCKET_PORT:-8082}${WS_HEALTH_PATH:-/actuator/health} || exit 1",
        ]
      interval: 10s
      timeout: 5s
      retries: 30
      start_period: 60s
    networks:
      - openisle-network

  frontend_dev:
    image: node:20
    container_name: openisle-frontend-dev
    working_dir: /app
    env_file:
      - ../.env
    command: sh -c "npm install && npm run dev"
    volumes:
      - ../frontend_nuxt:/app
      - frontend-node-modules:/app/node_modules
    ports:
      - "${FRONTEND_PORT:-3000}:3000"
    depends_on:
      springboot:
        condition: service_healthy
      websocket-service:
        condition: service_healthy
    networks:
      - openisle-network
    profiles:
      - dev

   frontend_service:
    build:
      context: ..                 # 仓库根目录（包含 frontend_nuxt/）
      dockerfile: docker/frontend-service.Dockerfile
      args:
        # 由 .env（或 --env-file）提供，默认 staging；正式环境脚本会传 production
        NUXT_ENV: ${NUXT_ENV:-staging}
    container_name: openisle-frontend
    env_file:
      - ../.env                   # 或者在脚本里指定 .env.staging / .env.production
    ports:
      - "${FRONTEND_PORT:-3000}:3000"
    depends_on:
      springboot:
        condition: service_healthy
      websocket-service:
        condition: service_healthy
    restart: unless-stopped

  loopback_8080:
    image: alpine/socat
    container_name: loopback-8080
    # 监听“frontend_dev 容器自身的” 127.0.0.1:8080 → 转发到 springboot:8080
    command:
      [
        "-d",
        "-d",
        "-ly",
        "TCP4-LISTEN:8080,bind=127.0.0.1,reuseaddr,fork",
        "TCP4:springboot:8080",
      ]
    depends_on:
      springboot:
        condition: service_healthy
    network_mode: "service:frontend_dev"
    profiles: ["dev"]
    healthcheck:
      test: ["CMD", "sh", "-c", "nc -z 127.0.0.1 8080"]
      interval: 5s
      timeout: 3s
      retries: 20
      start_period: 10s

  loopback_8082:
    image: alpine/socat
    container_name: loopback-8082
    # 监听 127.0.0.1:8082 → 转发到 websocket-service:8082（WS 纯 TCP 可直接过）
    command:
      [
        "-d",
        "-d",
        "-ly",
        "TCP4-LISTEN:8082,bind=127.0.0.1,reuseaddr,fork",
        "TCP4:websocket-service:8082",
      ]
    depends_on:
      websocket-service:
        condition: service_healthy
    network_mode: "service:frontend_dev"
    profiles: ["dev"]
    healthcheck:
      test: ["CMD", "sh", "-c", "nc -z 127.0.0.1 8082"]
      interval: 5s
      timeout: 3s
      retries: 20
      start_period: 10s

networks:
  openisle-network:
    driver: bridge

volumes:
  mysql-data:
  maven-repo:
  redis-data:
  rabbitmq-data:
  websocket-maven-repo:
  frontend-node-modules:
  frontend-service-node-modules:
  frontend-static: