#!/usr/bin/env bash
#
# bootstrap.sh — executa Fase 1 do deployment-guide automaticamente.
#
# Pré-requisitos:
#   - Node >= 22 (Quartz 4.5+ requer)
#   - git configurado com credenciais GitHub (SSH ou HTTPS com PAT)
#   - rsync instalado
#   - Acesso de push ao repo Anouk-Partners/colliers-costal-wiki
#
# O que faz:
#   1. Clona o repo vazio
#   2. Traz Quartz v4 como base (cópia simples, sem histórico upstream)
#   3. Mergea o scaffold deste vault
#   4. Instala dependências
#   5. Roda primeiro build local nos 3 targets (validação)
#   6. Commita tudo
#   7. Oferece push opcional
#
# Uso:
#   cd 99-operacao/publish/
#   bash bootstrap.sh [workspace_dir]
#
# Default workspace: ~/workspace
# Chama com --push para pushar automaticamente.

set -euo pipefail

# --- Configuração ---
REPO_URL="https://github.com/Anouk-Partners/colliers-costal-wiki.git"
QUARTZ_UPSTREAM="https://github.com/jackyzha0/quartz.git"
QUARTZ_BRANCH="v4"
WORKSPACE="${1:-$HOME/workspace}"
REPO_NAME="colliers-costal-wiki"
REPO_DIR="${WORKSPACE}/${REPO_NAME}"

# Caminho do vault (esta pasta é 99-operacao/publish/)
SCAFFOLD_DIR="$(cd "$(dirname "$0")" && pwd)"
VAULT_DIR="$(cd "${SCAFFOLD_DIR}/../.." && pwd)"

PUSH_AFTER_COMMIT=false
if [[ "${2:-}" == "--push" ]]; then
  PUSH_AFTER_COMMIT=true
fi

log() { printf "\n\033[1;36m▸ %s\033[0m\n" "$*"; }
err() { printf "\n\033[1;31m✗ %s\033[0m\n" "$*" >&2; exit 1; }

# --- Sanity checks ---
command -v node >/dev/null 2>&1 || err "Node >= 22 não encontrado"
command -v git >/dev/null 2>&1 || err "git não encontrado"
command -v rsync >/dev/null 2>&1 || err "rsync não encontrado"

NODE_MAJOR=$(node -v | sed 's/v\([0-9]*\).*/\1/')
if [[ "${NODE_MAJOR}" -lt 22 ]]; then
  err "Node ${NODE_MAJOR} é muito antigo. Quartz 4.5+ requer >= 22."
fi

mkdir -p "${WORKSPACE}"

# --- 1.1 Clonar o repo ---
if [[ -d "${REPO_DIR}" ]]; then
  log "Repo já existe em ${REPO_DIR} — pulando clone"
else
  log "Clonando ${REPO_URL} em ${REPO_DIR}"
  git clone "${REPO_URL}" "${REPO_DIR}"
fi

cd "${REPO_DIR}"

# --- 1.2 Trazer Quartz v4 como base ---
if [[ -f "quartz.config.ts" && -d "quartz" ]]; then
  log "Quartz v4 já presente no repo — pulando download"
else
  log "Baixando Quartz v4 e copiando como base"
  TMP_QUARTZ="$(mktemp -d)"
  git clone --branch "${QUARTZ_BRANCH}" --depth 1 "${QUARTZ_UPSTREAM}" "${TMP_QUARTZ}/quartz-base"
  rsync -av --exclude='.git' --exclude='content' "${TMP_QUARTZ}/quartz-base/" "${REPO_DIR}/"
  rm -rf "${TMP_QUARTZ}"
fi

# --- 1.3 Instalar deps ---
log "Instalando dependências Quartz"
if [[ -f "package-lock.json" ]]; then
  npm ci
else
  npm install
fi

# --- 1.4 Mergear scaffold deste vault ---
log "Copiando scaffold do vault para o repo Quartz"

cp "${SCAFFOLD_DIR}/quartz/quartz.config.ts" "${REPO_DIR}/quartz.config.ts"

mkdir -p "${REPO_DIR}/quartz/plugins/filters"
cp "${SCAFFOLD_DIR}/quartz/filters/audience-filter.ts" "${REPO_DIR}/quartz/plugins/filters/audience-filter.ts"
cp "${SCAFFOLD_DIR}/quartz/filters/ignore-patterns.ts" "${REPO_DIR}/quartz/plugins/filters/ignore-patterns.ts"

mkdir -p "${REPO_DIR}/.github/workflows"
cp "${SCAFFOLD_DIR}/workflows/wiki.yml" "${REPO_DIR}/.github/workflows/wiki.yml"

# Adicionar exports em filters/index.ts (se existir e ainda não tiver)
FILTERS_INDEX="${REPO_DIR}/quartz/plugins/filters/index.ts"
if [[ -f "${FILTERS_INDEX}" ]]; then
  if ! grep -q "AudienceFilter" "${FILTERS_INDEX}"; then
    log "Adicionando exports de AudienceFilter e IgnorePatterns em filters/index.ts"
    cat >> "${FILTERS_INDEX}" <<'EOF'

export { AudienceFilter } from "./audience-filter"
export { IgnorePatterns } from "./ignore-patterns"
EOF
  fi
fi

# --- 1.5 Sync inicial vault → content/ (one-off local) ---
log "Sincronizando vault para content/ (via rsync, sem credenciais Drive ainda)"
mkdir -p "${REPO_DIR}/content"
rsync -av --delete \
  --exclude='.obsidian' \
  --exclude='_bases' \
  --exclude='_templates' \
  --exclude='99-operacao/scripts' \
  --exclude='agentes-core/axios/memory' \
  --exclude='.DS_Store' \
  --exclude='Saída do Terminal.md' \
  --exclude='.git' \
  "${VAULT_DIR}/" "${REPO_DIR}/content/"

# Quartz espera content/index.md como homepage. Copiar HOME.md → index.md.
if [[ -f "${REPO_DIR}/content/HOME.md" ]]; then
  log "Copiando HOME.md → index.md (homepage Quartz)"
  cp "${REPO_DIR}/content/HOME.md" "${REPO_DIR}/content/index.md"
fi

# Converter _index.md → index.md em todas as pastas
log "Renomeando _index.md → index.md em content/"
find "${REPO_DIR}/content" -name "_index.md" | while read -r f; do
  dir=$(dirname "$f")
  if [[ ! -f "${dir}/index.md" ]]; then
    mv "$f" "${dir}/index.md"
  fi
done

# Reescrever wikilinks [[.../_index...]] → [[.../index...]]
log "Reescrevendo wikilinks para o novo padrão"
# macOS (BSD sed) requer -i '' ; Linux (GNU sed) requer -i sem sufixo.
if [[ "$(uname)" == "Darwin" ]]; then
  SED_INPLACE=(-i "")
else
  SED_INPLACE=(-i)
fi
find "${REPO_DIR}/content" -name "*.md" -type f -exec sed "${SED_INPLACE[@]}" \
  -e 's|\[\[\([^]|]*\)/_index|[[\1/index|g' \
  -e 's|\[\[_index\([|]\)|[[index\1|g' \
  -e 's|\[\[_index\]\]|[[index]]|g' \
  {} +

# Publicação: preservar folder notes prefixados no vault, mas expor esses
# conteúdos como index.md dentro da pasta correspondente no Quartz.
copy_folder_note() {
  local src="${REPO_DIR}/content/$1"
  local dest="${REPO_DIR}/content/$2"
  if [[ -f "${src}" ]]; then
    mkdir -p "$(dirname "${dest}")"
    cp "${src}" "${dest}"
  fi
}

copy_folder_note "01-colliers/colliers-agentes.md" "01-colliers/agentes/index.md"
copy_folder_note "01-colliers/colliers-dados.md" "01-colliers/dados/index.md"
copy_folder_note "01-colliers/colliers-meetings.md" "01-colliers/meetings/index.md"
copy_folder_note "01-colliers/colliers-specs.md" "01-colliers/specs/index.md"
copy_folder_note "02-costal/costal-agentes.md" "02-costal/agentes/index.md"
copy_folder_note "02-costal/costal-dados.md" "02-costal/dados/index.md"
copy_folder_note "02-costal/governanca.md" "02-costal/governanca/index.md"
copy_folder_note "02-costal/costal-meetings.md" "02-costal/meetings/index.md"
copy_folder_note "02-costal/costal-pesquisa.md" "02-costal/pesquisa/index.md"
copy_folder_note "02-costal/costal-plano.md" "02-costal/plano/index.md"
copy_folder_note "02-costal/costal-specs.md" "02-costal/specs/index.md"

# --- 1.6 Primeiro build local nos 3 targets ---
# Quartz v4 não aceita --config; sempre usa ./quartz.config.ts.
# A audiência é controlada via env var AUDIENCE (lida pela config).
log "Build Quartz (internal)"
AUDIENCE=internal BASE_URL=interno.colliers.wiki.anoukpartners.com \
  npx quartz build --output public-internal || err "Build internal falhou"

log "Build Quartz (client)"
AUDIENCE=client BASE_URL=cliente.colliers.wiki.anoukpartners.com \
  npx quartz build --output public-client || err "Build client falhou"

log "Build Quartz (board)"
AUDIENCE=board BASE_URL=board.colliers.wiki.anoukpartners.com \
  npx quartz build --output public-board || err "Build board falhou"

log "3 builds OK — saídas em public-internal/, public-client/, public-board/"

# --- 1.7 gitignore ---
GITIGNORE_PATH="${REPO_DIR}/.gitignore"
if ! grep -q "public-" "${GITIGNORE_PATH}" 2>/dev/null; then
  log "Adicionando entradas ao .gitignore"
  cat >> "${GITIGNORE_PATH}" <<'EOF'

# Quartz output builds (não commitar)
public/
public-*/
.quartz-cache/

# Content sync — alternativa é commitar; por default não
# content/
EOF
fi

# --- 1.8 Commit ---
log "Preparando commit"
git config user.name  "$(git config user.name  || echo 'Anouk Publish Bot')"
git config user.email "$(git config user.email || echo 'ops@anoukpartners.com')"

git add .
if git diff --staged --quiet; then
  log "Nada novo para commitar — repo já está sincronizado"
else
  git commit -m "feat: Quartz v4 base + scaffold audience filter (3 audiences)

- Quartz v4 base via cópia simples
- Filtros: AudienceFilter + IgnorePatterns
- Configs: internal / client / board (matrix)
- Workflow GitHub Actions (sync + build + deploy Cloudflare Pages)
- Content inicial sincronizado do vault"
fi

# --- 1.9 Push (opcional) ---
if [[ "${PUSH_AFTER_COMMIT}" == "true" ]]; then
  log "Pushing para origin/main"
  git push origin main
else
  log "Commit local pronto. Para push manual: cd ${REPO_DIR} && git push origin main"
fi

echo ""
echo "═════════════════════════════════════════════════════════════"
echo "✅  Bootstrap completo"
echo "═════════════════════════════════════════════════════════════"
echo ""
echo "Próximos passos:"
echo "  1. Revisar builds em: ${REPO_DIR}/public-{internal,client,board}"
echo "  2. Servir localmente:  cd ${REPO_DIR} && npx quartz build --serve --output public-internal"
echo "  3. Se não usou --push: cd ${REPO_DIR} && git push origin main"
echo "  4. Seguir Fase 2 do deployment-guide (Cloudflare Pages + Access)"
echo ""