name: FHIR IG CI/CD Pipeline with Version Persistence

on:
  push:
    tags:
      - 'v*.*.*'
  pull_request:
    branches: [ main ]

permissions:
  contents: read

concurrency:
  group: fhir-ig-${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  REGISTRY: git.dghs.gov.bd
  IMAGE_NAME: gitadmin/bd-core-fhir-ig

defaults:
  run:
    shell: bash

jobs:
  build-ig:
    runs-on: fhir-runner

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Extract version from IG
        id: version
        run: |
          set -euo pipefail

          VERSION="$(grep -oP '<version value="\K[^"]+' input/bd.fhir.core.xml | head -1 || true)"

          if [[ -z "${VERSION}" ]]; then
            echo "ERROR: Could not extract version from ImplementationGuide XML"
            exit 1
          fi

          echo "Extracted version: ${VERSION}"
          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"

          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
            BUILD_TYPE="release"
            TAG_VERSION="${GITHUB_REF#refs/tags/v}"

            if [[ "${TAG_VERSION}" != "${VERSION}" ]]; then
              echo "ERROR: Git tag version (${TAG_VERSION}) doesn't match IG version (${VERSION})"
              exit 1
            fi
          else
            BUILD_TYPE="dev"
          fi

          echo "build_type=${BUILD_TYPE}" >> "$GITHUB_OUTPUT"
          echo "Build type: ${BUILD_TYPE}"

      - name: Prepare package-list.json and history.xml
        env:
          VERSION: ${{ steps.version.outputs.version }}
          BUILD_TYPE: ${{ steps.version.outputs.build_type }}
        run: |
          set -euo pipefail

          DATE="$(date +%Y-%m-%d)"
          export VERSION BUILD_TYPE DATE

          echo "Preparing package-list.json and history.xml..."

          if [[ ! -f package-list.json ]]; then
            echo "package-list.json not found in repo root. Creating initial file..."
            cat > package-list.json <<'PKGEOF'
          {
            "package-id": "bd.fhir.core",
            "title": "Bangladesh Core FHIR Implementation Guide",
            "canonical": "https://fhir.dghs.gov.bd/core",
            "introduction": "The Bangladesh Core FHIR IG defines national base profiles, value sets, and extensions for health data interoperability.",
            "list": [
              {
                "version": "current",
                "desc": "Continuous Integration Build (latest in version control)",
                "path": "https://fhir.dghs.gov.bd/core/",
                "status": "ci-build",
                "current": true
              }
            ]
          }
          PKGEOF
          fi

          python3 <<'PYEOF'
          import json
          import os
          import sys
          from html import escape
          from pathlib import Path

          version = os.environ["VERSION"]
          date = os.environ["DATE"]
          build_type = os.environ["BUILD_TYPE"]

          pkg_path = Path("package-list.json")
          with pkg_path.open("r", encoding="utf-8") as f:
              pkg_list = json.load(f)

          if "list" not in pkg_list or not isinstance(pkg_list["list"], list):
              print("ERROR: package-list.json does not contain a valid 'list' array")
              sys.exit(1)

          if not any(e.get("version") == "current" for e in pkg_list["list"]):
              pkg_list["list"].insert(0, {
                  "version": "current",
                  "desc": "Continuous Integration Build (latest in version control)",
                  "path": "https://fhir.dghs.gov.bd/core/",
                  "status": "ci-build",
                  "current": True
              })

          if build_type == "release":
              existing = next((e for e in pkg_list["list"] if e.get("version") == version), None)
              if existing is None:
                  new_entry = {
                      "version": version,
                      "date": date,
                      "desc": f"Release {version}",
                      "path": f"https://fhir.dghs.gov.bd/core/{version}/",
                      "status": "trial-use",
                      "sequence": "STU 1"
                  }
                  insert_index = 1
                  for i, entry in enumerate(pkg_list["list"]):
                      if entry.get("version") == "current":
                          insert_index = i + 1
                          break
                  pkg_list["list"].insert(insert_index, new_entry)
                  print(f"Added version {version} to package-list.json")
              else:
                  print(f"Version {version} already exists in package-list.json")
          else:
              print("Dev build - keeping existing package-list.json structure")

          with pkg_path.open("w", encoding="utf-8") as f:
              json.dump(pkg_list, f, indent=2, ensure_ascii=False)

          Path("input").mkdir(parents=True, exist_ok=True)
          Path("input/package-list.json").write_text(
              pkg_path.read_text(encoding="utf-8"),
              encoding="utf-8"
          )

          Path("input/pagecontent").mkdir(parents=True, exist_ok=True)

          def version_key(v: str):
              try:
                  return tuple(int(x) for x in v.split("."))
              except Exception:
                  return (0,)

          published = [
              e for e in pkg_list["list"]
              if e.get("version") and e.get("version") != "current"
          ]
          published.sort(key=lambda e: version_key(e.get("version", "0.0.0")), reverse=True)

          xml_parts = [
              '<?xml version="1.0" encoding="UTF-8"?>',
              '<div xmlns="http://www.w3.org/1999/xhtml">',
              '',
              '<p>This page provides the version history for the Bangladesh Core FHIR Implementation Guide.</p>',
              '',
              '<p>For a machine-readable version history see <a href="package-list.json">package-list.json</a>.</p>',
              '',
              '<p><b>Published Versions</b></p>',
              '',
              '<table class="grid table table-striped table-bordered table-hover">',
              '<thead>',
              '<tr>',
              '<th>Version</th>',
              '<th>Date</th>',
              '<th>Status</th>',
              '<th>Description</th>',
              '</tr>',
              '</thead>',
              '<tbody>',
          ]

          if published:
              for idx, entry in enumerate(published):
                  version_escaped = escape(entry.get("version", "Unknown"))
                  date_escaped = escape(entry.get("date", "N/A"))
                  desc_escaped = escape(entry.get("desc", ""))
                  path_escaped = escape(entry.get("path", "#"))
                  status_val = entry.get("status", "unknown")

                  if status_val == "trial-use":
                      status = '<span class="badge bg-info">Trial Use</span>'
                  elif status_val == "normative":
                      status = '<span class="badge bg-success">Normative</span>'
                  else:
                      status = f'<span class="badge bg-secondary">{escape(status_val)}</span>'

                  badge = '<span class="badge bg-success">Latest</span> ' if idx == 0 else ''

                  xml_parts.extend([
                      '<tr>',
                      f'<td><a href="{path_escaped}">{badge}{version_escaped}</a></td>',
                      f'<td>{date_escaped}</td>',
                      f'<td>{status}</td>',
                      f'<td>{desc_escaped}</td>',
                      '</tr>',
                  ])
          else:
              xml_parts.extend([
                  '<tr>',
                  '<td colspan="4">No published versions available yet.</td>',
                  '</tr>',
              ])

          xml_parts.extend([
              '</tbody>',
              '</table>',
              '',
              '<p class="lead"><b>Continuous Integration Build</b></p>',
          ])

          current_entry = next((e for e in pkg_list["list"] if e.get("version") == "current"), None)
          if current_entry:
              path_escaped = escape(current_entry.get("path", pkg_list.get("canonical", "") + "/"))
              xml_parts.append(
                  f'<p>The latest development build is available at: <a href="{path_escaped}">{path_escaped}</a></p>'
              )
          else:
              xml_parts.append('<p><i>No CI build entry found in package-list.json.</i></p>')

          xml_parts.extend(['', '</div>', ''])

          Path("input/pagecontent/history.xml").write_text(
              "\n".join(xml_parts),
              encoding="utf-8"
          )

          print("Generated input/pagecontent/history.xml")
          PYEOF

          python3 -m json.tool package-list.json > /dev/null
          test -f input/package-list.json
          test -f input/pagecontent/history.xml

          echo "Prepared files:"
          echo "  - $(pwd)/package-list.json"
          echo "  - $(pwd)/input/package-list.json"
          echo "  - $(pwd)/input/pagecontent/history.xml"

      - name: Lightweight disk cleanup
        run: |
          set -euo pipefail

          echo "Disk usage before cleanup:"
          df -h

          AVAIL_GB="$(df -BG "$GITHUB_WORKSPACE" | awk 'NR==2 {gsub(/G/, "", $4); print $4}')"

          if [[ "${AVAIL_GB}" -lt 10 ]]; then
            echo "Low free disk detected (${AVAIL_GB}G). Running safe cleanup..."
            docker system prune -af || true
            rm -rf "${GITHUB_WORKSPACE}/output" \
                   "${GITHUB_WORKSPACE}/temp" \
                   "${GITHUB_WORKSPACE}/input-cache" \
                   "${GITHUB_WORKSPACE}/fsh-generated" || true
            rm -rf ~/.fhir/packages || true
          else
            echo "Sufficient disk available (${AVAIL_GB}G). Skipping aggressive cleanup."
          fi

          echo "Disk usage after cleanup:"
          df -h

      - name: Ensure Docker is available
        run: |
          set -euo pipefail

          if command -v docker >/dev/null 2>&1; then
            echo "Docker already installed: $(docker --version)"
            exit 0
          fi

          echo "Docker not found. Installing..."
          sudo apt-get update
          sudo apt-get install -y docker.io
          docker --version

      - name: Preload previous IG package for comparison
        env:
          VERSION: ${{ steps.version.outputs.version }}
        run: |
          set -euo pipefail

          echo "Detecting previous version..."

          PREV_VERSION="$(
            python3 <<'PY'
          import json
          import os

          current_build = os.environ.get("VERSION", "")

          with open("package-list.json", encoding="utf-8") as f:
              data = json.load(f)

          def parse(v):
              try:
                  return tuple(int(x) for x in v.split("."))
              except Exception:
                  return (0,)

          versions = [
              entry["version"]
              for entry in data.get("list", [])
              if entry.get("version") not in ("current", current_build)
          ]
          versions.sort(key=parse, reverse=True)
          print(versions[0] if versions else "")
          PY
          )"

          rm -rf previous-packages
          mkdir -p previous-packages

          if [[ -z "${PREV_VERSION}" ]]; then
            echo "No previous version found. Skipping preload."
            exit 0
          fi

          echo "Previous version detected: ${PREV_VERSION}"

          TMPDIR="$(mktemp -d)"
          trap 'rm -rf "$TMPDIR"' EXIT

          URL="https://fhir.dghs.gov.bd/core/${PREV_VERSION}/package.tgz"
          echo "Downloading ${URL}"
          curl -fL "${URL}" -o "${TMPDIR}/package.tgz"

          mkdir -p "previous-packages/bd.fhir.core#${PREV_VERSION}"
          tar -xzf "${TMPDIR}/package.tgz" -C "previous-packages/bd.fhir.core#${PREV_VERSION}"

          echo "Previous package cached:"
          ls -lah previous-packages

      - name: Build FHIR IG
        env:
          VERSION: ${{ steps.version.outputs.version }}
        run: |
          set -euo pipefail

          echo "Building FHIR IG version ${VERSION}..."

          CONTAINER_ID="$(
            docker create \
              -v "$(pwd)/previous-packages:/previous-packages" \
              hl7fhir/ig-publisher-base:latest \
              /bin/bash -lc '
                set -euo pipefail
                mkdir -p /tmp/build
                cp -r /home/publisher/ig /tmp/build/ig
                cd /tmp/build/ig
                rm -f package-list.json
                _updatePublisher.sh -y
                _genonce.sh
              '
          )"

          echo "Container ID: ${CONTAINER_ID}"

          cleanup() {
            docker rm -f "${CONTAINER_ID}" >/dev/null 2>&1 || true
          }
          trap cleanup EXIT

          docker cp "$(pwd)/." "${CONTAINER_ID}:/home/publisher/ig/"

          echo "Mounted previous packages:"
          ls -R previous-packages || echo "No previous packages directory"

          docker start -a "${CONTAINER_ID}"
          EXIT_CODE=$?

          echo "Copying outputs from container..."
          docker cp "${CONTAINER_ID}:/tmp/build/ig/output" ./output || echo "Warning: No output directory"
          docker cp "${CONTAINER_ID}:/tmp/build/ig/fsh-generated" ./fsh-generated || echo "No FSH generated"
          docker cp "${CONTAINER_ID}:/tmp/build/ig/input-cache" ./input-cache || echo "No input-cache"
          docker cp "${CONTAINER_ID}:/tmp/build/ig/temp" ./temp || echo "No temp directory"

          if [[ ${EXIT_CODE} -ne 0 ]]; then
            echo "Build failed."
            exit "${EXIT_CODE}"
          fi

          if [[ ! -f output/index.html ]]; then
            echo "ERROR: Build failed - output/index.html not found"
            exit 1
          fi

          echo "Checking for history.html..."
          if [[ -f output/history.html ]]; then
            echo "history.html generated successfully"
            ls -lh output/history.html
          else
            echo "WARNING: history.html was not generated"
          fi

          echo "IG Publisher comparison log:"
          cat output/qa.compare.txt || echo "qa.compare.txt not found"

          echo "Build successful"

      - name: Update package-feed.xml for releases
        if: steps.version.outputs.build_type == 'release'
        env:
          VERSION: ${{ steps.version.outputs.version }}
        run: |
          set -euo pipefail

          DATETIME="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
          export DATETIME

          if [[ ! -f package-feed.xml ]]; then
            echo "package-feed.xml not found, creating initial feed..."
            cat > package-feed.xml <<EOF
          <?xml version="1.0" encoding="UTF-8"?>
          <feed xmlns="http://www.w3.org/2005/Atom">
            <title>bd.fhir.core</title>
            <id>https://fhir.dghs.gov.bd/core/package-feed.xml</id>
            <updated>${DATETIME}</updated>
          </feed>
          EOF
          fi

          python3 <<'PYEOF'
          import os
          import xml.etree.ElementTree as ET

          version = os.environ["VERSION"]
          datetime_iso = os.environ["DATETIME"]

          ET.register_namespace('', 'http://www.w3.org/2005/Atom')

          tree = ET.parse('package-feed.xml')
          root = tree.getroot()
          ns = {'atom': 'http://www.w3.org/2005/Atom'}

          updated_elem = root.find('atom:updated', ns)
          if updated_elem is not None:
              updated_elem.text = datetime_iso

          entry_exists = False
          for entry in root.findall('atom:entry', ns):
              title = entry.find('atom:title', ns)
              if title is not None and version in (title.text or ''):
                  entry_exists = True
                  entry_updated = entry.find('atom:updated', ns)
                  if entry_updated is not None:
                      entry_updated.text = datetime_iso
                  break

          if not entry_exists:
              new_entry = ET.Element('{http://www.w3.org/2005/Atom}entry')

              title = ET.SubElement(new_entry, '{http://www.w3.org/2005/Atom}title')
              title.text = f"bd.fhir.core version {version}"

              link = ET.SubElement(new_entry, '{http://www.w3.org/2005/Atom}link')
              link.set('rel', 'alternate')
              link.set('href', f"https://fhir.dghs.gov.bd/core/{version}/")

              entry_id = ET.SubElement(new_entry, '{http://www.w3.org/2005/Atom}id')
              entry_id.text = f"https://fhir.dghs.gov.bd/core/{version}/"

              entry_updated = ET.SubElement(new_entry, '{http://www.w3.org/2005/Atom}updated')
              entry_updated.text = datetime_iso

              summary = ET.SubElement(new_entry, '{http://www.w3.org/2005/Atom}summary')
              summary.text = f"Release {version} of Bangladesh Core FHIR Implementation Guide"

              insert_pos = 0
              for i, child in enumerate(root):
                  if child.tag.endswith('entry'):
                      insert_pos = i
                      break
                  insert_pos = i + 1

              root.insert(insert_pos, new_entry)

          tree.write('output/package-feed.xml', encoding='utf-8', xml_declaration=True)
          print("Updated package-feed.xml")
          PYEOF

          cp package-list.json output/package-list.json
          echo "Updated registry files"

      - name: Prepare deployment artifact
        run: |
          set -euo pipefail

          VERSION="${{ steps.version.outputs.version }}"
          BUILD_TYPE="${{ steps.version.outputs.build_type }}"
          BUILD_DATE="$(date -u +%Y-%m-%dT%H:%M:%SZ)"

          tar -czf ig-output.tar.gz -C output .

          {
            echo "version=${VERSION}"
            echo "build_type=${BUILD_TYPE}"
            echo "build_date=${BUILD_DATE}"
          } > deployment.env

          echo "Output contents:"
          ls -lh output/ | grep -E "(history\.html|package-list\.json|package-feed\.xml|index\.html)" || echo "Some files may be missing"

          ls -lh ig-output.tar.gz

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: ig-output
          path: |
            ig-output.tar.gz
            deployment.env
            package-list.json
            package-feed.xml
          if-no-files-found: warn
          retention-days: 30

  deploy:
    needs: build-ig
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v')

    steps:
      - name: Download artifact
        uses: actions/download-artifact@v4
        with:
          name: ig-output

      - name: Load deployment env
        id: deploy_info
        run: |
          set -euo pipefail

          source deployment.env

          echo "version=${version}" >> "$GITHUB_OUTPUT"
          echo "build_type=${build_type}" >> "$GITHUB_OUTPUT"
          echo "build_date=${build_date}" >> "$GITHUB_OUTPUT"

          echo "Deploying version: ${version}"
          echo "Build type: ${build_type}"

      - name: Deploy files to server
        uses: appleboy/scp-action@v0.1.7
        with:
          host: ${{ secrets.DEPLOY_HOST }}
          username: ${{ secrets.DEPLOY_USER }}
          password: ${{ secrets.DEPLOY_PASSWORD }}
          port: ${{ secrets.DEPLOY_PORT || 22 }}
          source: "ig-output.tar.gz,deployment.env,package-list.json,package-feed.xml"
          target: "/tmp/fhir-ig-deploy/"

      - name: Execute deployment on server
        uses: appleboy/ssh-action@v1.0.3
        with:
          host: ${{ secrets.DEPLOY_HOST }}
          username: ${{ secrets.DEPLOY_USER }}
          password: ${{ secrets.DEPLOY_PASSWORD }}
          port: ${{ secrets.DEPLOY_PORT || 22 }}
          script: |
            set -euo pipefail

            source /tmp/fhir-ig-deploy/deployment.env

            echo "=========================================="
            echo "Deploying FHIR IG"
            echo "Version: $version"
            echo "Build Type: $build_type"
            echo "Build Date: $build_date"
            echo "=========================================="

            VERSIONS_DIR="/opt/fhir-ig/versions"
            mkdir -p "$VERSIONS_DIR"

            if [[ "$build_type" == "release" ]]; then
              TARGET_DIR="$VERSIONS_DIR/$version"
              echo "Deploying release version to: $TARGET_DIR"
            else
              TARGET_DIR="$VERSIONS_DIR/dev"
              echo "Deploying dev build to: $TARGET_DIR"
              mkdir -p "$TARGET_DIR"
              echo "Cleaning old dev files..."
              rm -rf "$TARGET_DIR"/*
            fi

            mkdir -p "$TARGET_DIR"

            echo "Extracting IG output..."
            tar -xzf /tmp/fhir-ig-deploy/ig-output.tar.gz -C "$TARGET_DIR"

            if [[ -f "$TARGET_DIR/history.html" ]]; then
              echo "history.html deployed successfully"
            else
              echo "WARNING: history.html not found in deployment"
            fi

            if [[ -f "$TARGET_DIR/package-list.json" ]]; then
              cp "$TARGET_DIR/package-list.json" "$VERSIONS_DIR/package-list.json"
              cp "$TARGET_DIR/package-list.json" "/opt/fhir-ig/package-list.json"
            elif [[ -f /tmp/fhir-ig-deploy/package-list.json ]]; then
              cp /tmp/fhir-ig-deploy/package-list.json "$VERSIONS_DIR/package-list.json"
              cp /tmp/fhir-ig-deploy/package-list.json "/opt/fhir-ig/package-list.json"
            fi

            if [[ -f "$TARGET_DIR/package-feed.xml" ]]; then
              cp "$TARGET_DIR/package-feed.xml" "$VERSIONS_DIR/package-feed.xml"
              cp "$TARGET_DIR/package-feed.xml" "/opt/fhir-ig/package-feed.xml"
            elif [[ -f /tmp/fhir-ig-deploy/package-feed.xml ]]; then
              cp /tmp/fhir-ig-deploy/package-feed.xml "$VERSIONS_DIR/package-feed.xml"
              cp /tmp/fhir-ig-deploy/package-feed.xml "/opt/fhir-ig/package-feed.xml"
            fi

            if [[ "$build_type" == "release" ]]; then
              echo "Updating current symlink to point to $version"
              ln -sfn "$version" "$VERSIONS_DIR/current"
            fi

            cd /opt/fhir-ig

            if [[ ! -f docker-compose.prod.yml ]]; then
              echo "ERROR: docker-compose.prod.yml not found!"
              exit 1
            fi

            docker compose -f docker-compose.prod.yml up -d --force-recreate fhir-ig

            rm -rf /tmp/fhir-ig-deploy

            echo "=========================================="
            echo "Deployment completed successfully"
            if [[ "$build_type" == "release" ]]; then
              echo "  - https://fhir.dghs.gov.bd/core/$version/"
              echo "  - https://fhir.dghs.gov.bd/core/$version/history.html"
              echo "  - https://fhir.dghs.gov.bd/core/ (current)"
            else
              echo "  - https://fhir.dghs.gov.bd/core/dev/"
            fi
            echo "=========================================="

            echo "Available versions:"
            ls -lh "$VERSIONS_DIR" | grep -v total || true