import { twinError } from '../../engine/log.js'
import { Arg, Ctx, Mutation, Query, Resolver, Directive} from 'type-graphql'

import { ScalarObject, getRepository } from '@things-factory/shell'

import { TwinSpace } from './twin-space.js'
import { TwinSpaceRepresentation } from './twin-space-representation.js'
import { REPRESENTATION_ROLES } from './representation-role.js'
import { TwinSpaceArea } from './twin-space-area.js'
import { TwinArea } from './twin-area.js'
import { TwinInstance } from '../twin-instance/twin-instance.js'
import { TwinAuditEvent } from '../twin-audit/twin-audit-event.js'
import { TwinEngine } from '../../engine/index.js'
import { judgeMoveTwinSpace, judgeDetachTwinSpace } from './move-space.js'
import { checkSpaceIntegrity, sortFindings, type IntegrityPolygon } from './space-integrity.js'

/*
 * 공간 구성 채널(design/ui/space-composition.md) — Site(Space) + 복수 표현(Representation) + 영역(Area).
 * model 내용은 board-service Board 에(표현 config.boardId 참조, 중복 저장 금지). 모두 domain 스코프.
 */
@Resolver()
export class TwinSpaceResolver {
  /* ── Space(Site) ────────────────────────────────────────────────── */
  /**
   * 이 테넌트의 현장 목록.
   *
   * ── 세 번만 묻는다 (2026-08-13) ──────────────────────────────────────────
   * 예전에는 현장마다 표현 수를 세고 인스턴스를 조회했다 — 현장 13곳이면 **질의 27번**이고, 첫
   * 호출이 2.4초였다(헤더가 뜰 때마다 이 목록을 읽는다). 규모가 커지면 그대로 자란다.
   *
   * 이제 세 번 묻고 메모리에서 맞춘다: 현장 · 표현(공간 id 만) · 인스턴스(필요한 컬럼만).
   * 표현은 **id 만 실어 온다**(`loadRelationIds`) — 설정 blob 을 읽어 세는 것은 낭비다.
   */
  @Query(returns => [ScalarObject], { description: 'List tenant Spaces (Sites) in the current domain.' })
  async twinSpaces(@Ctx() context: ResolverContext): Promise<any[]> {
    const domainId = context.state.domain.id
    const [rows, reps, insts] = await Promise.all([
      getRepository(TwinSpace).find({ where: { domain: { id: domainId } }, order: { createdAt: 'ASC' } }),
      /* 관계를 **조인해서** 읽는다 — `loadRelationIds`+`select` 조합은 관계 자리를 비워 두어
         표현 수가 전부 0 이 됐다(2026-08-13 실측으로 잡음). 조인 한 번이 현장마다 세는 것보다 싸다. */
      getRepository(TwinSpaceRepresentation).find({ where: { domain: { id: domainId } }, relations: { space: true } }),
      getRepository(TwinInstance).find({ where: { domain: { id: domainId } }, select: { instanceId: true, spaceId: true, purpose: true, copyOf: true } })
    ])

    const repCount = new Map<string, number>()
    for (const rep of reps) {
      const sid = rep.space?.id
      if (sid) repCount.set(sid, (repCount.get(sid) ?? 0) + 1)
    }
    /* 벤치 여부·원본 참조 — 인스턴스 purpose 근거(1급). 사본 현장을 헤더 선택기에서 구별·선택 가능하게. */
    const benchOf = new Map<string, { copyOf?: string }>()
    for (const i of insts) if ((i as any).purpose === 'bench' && i.spaceId && !benchOf.has(i.spaceId)) benchOf.set(i.spaceId, { copyOf: i.copyOf ?? undefined })

    return rows.map(r => {
      const bench = benchOf.get(r.spaceId)
      return {
        spaceId: r.spaceId,
        name: r.name,
        description: r.description,
        geo: r.geo,
        timezone: r.timezone,
        primaryRepresentationId: r.primaryRepresentationId,
        extentX: r.extentX,
        extentY: r.extentY,
        representationCount: repCount.get(r.id) ?? 0,
        bench: !!bench,
        copyOf: bench?.copyOf
      }
    })
  }

  /** 단건 — 표현(+영역) 트리 포함. */
  @Query(returns => ScalarObject, { nullable: true, description: 'Get one Space with its representations (and their areas).' })
  async twinSpace(@Arg('spaceId') spaceId: string, @Ctx() context: ResolverContext): Promise<any | null> {
    const domainId = context.state.domain.id
    const r = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
    if (!r) return null
    /*
     * 묶은 이름 다음에 순서로 정렬한다. `group` 이 비어 있는 행이 앞에 오는지 뒤에 오는지는 드라이버마다
     * 다르므로 그 순서에 기대지 않는다 — 화면이 다시 묶는다(UX 레인과 그렇게 정했다).
     */
    const reps = await getRepository(TwinSpaceRepresentation).find({
      where: { domain: { id: domainId }, space: { id: r.id } },
      order: { group: 'ASC', seq: 'ASC' }
    })
    const representations: any[] = []
    for (const rep of reps) {
      const areas = await getRepository(TwinSpaceArea).find({ where: { domain: { id: domainId }, representation: { id: rep.id } }, order: { createdAt: 'ASC' } })
      representations.push({ id: rep.id, type: rep.type, name: rep.name, seq: rep.seq, group: rep.group, role: rep.role, isPrimary: rep.isPrimary, config: rep.config, areas: areas.map(a => ({ id: a.id, name: a.name, type: a.type, geometry: a.geometry, drillTo: a.drillTo, binding: a.binding, style: a.style })) })
    }
    return { spaceId: r.spaceId, name: r.name, description: r.description, geo: r.geo, timezone: r.timezone, primaryRepresentationId: r.primaryRepresentationId, extentX: r.extentX, extentY: r.extentY, representations }
  }

  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Create or update a Space (name/description/geo/timezone/primaryRepresentationId).' })
  async saveTwinSpace(
    @Arg('spaceId') spaceId: string,
    @Arg('patch', type => ScalarObject) patch: any,
    @Ctx() context: ResolverContext
  ): Promise<boolean> {
    const repo = getRepository(TwinSpace)
    const domainId = context.state.domain.id
    const existing = await repo.findOne({ where: { domain: { id: domainId }, spaceId } })
    /* 진짜 부분 병합 — patch 에 준 키만 갱신(나머지 필드 보존). id 는 관계로 재설정하지 않도록 제외. */
    const { id: _drop, ...clean } = patch ?? {}
    await repo.save(repo.create({ ...(existing ?? {}), ...clean, domain: { id: domainId } as any, spaceId }))
    return true
  }

  /**
   * 공간 삭제 — **이 공간의 트윈이 있으면 거절한다.** 그래서 트윈이 현장을 잃는 일은 없다.
   *
   * ── 왜 모양을 바꿨나 (2026-08-13) ────────────────────────────────────────
   * 예전에는 `Boolean` 을 돌려주고 거절은 **한국어 문장을 냈다.** 두 가지가 틀렸다:
   *  ① 서버가 화면의 말을 정했다 — 일본어·스페인어 사용자에게 한국어가 새어 나간다.
   *  ② 오류를 낸 예외를 화면이 받지 않아 **아무 일도 없는 것처럼** 보였다. 사용자는 삭제를 눌렀고
   *     화면은 그대로였다. 거절을 알리지 않고 하는 것은 실패보다 나쁘다.
   * 이제 `{ok, errorCode, errorParams}` 로 낸다 — 화면이 `twin.compose.del.<code>` 로 말을 만든다.
   */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, {
    description:
      'Delete a Space and its representations/areas. Refused while twins still live in it (a twin never loses its site this way). Returns {ok, errorCode, errorParams}.'
  })
  async deleteTwinSpace(@Arg('spaceId') spaceId: string, @Ctx() context: ResolverContext): Promise<any> {
    const domainId = context.state.domain.id
    // 라이프사이클 가드 — 이 공간에 바인딩된 트윈 인스턴스가 있으면 삭제 차단(dangling 방지).
    // spaceId 컬럼(space #3) 로 직접 질의 — 전 인스턴스 로드+JS필터 제거(효율·1급 질의).
    const bound = await getRepository(TwinInstance).find({ where: { domain: { id: domainId }, spaceId } })
    if (bound.length) {
      const twins = bound.map(i => i.name || i.instanceId)
      return {
        ok: false,
        errorCode: 'space-has-twins',
        errorParams: { spaceId, count: bound.length, twins: twins.slice(0, 5).join(', ') },
        error: `space "${spaceId}" still has ${bound.length} twin(s) — remove or move them first (${twins.join(', ')})`
      }
    }
    const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
    if (space) {
      const reps = await getRepository(TwinSpaceRepresentation).find({ where: { domain: { id: domainId }, space: { id: space.id } } })
      for (const rep of reps) await getRepository(TwinSpaceArea).delete({ domain: { id: domainId } as any, representation: { id: rep.id } as any })
      await getRepository(TwinSpaceRepresentation).delete({ domain: { id: domainId } as any, space: { id: space.id } as any })
      await getRepository(TwinArea).delete({ domain: { id: domainId } as any, space: { id: space.id } as any }) // 논리 area 도 함께 정리
    }
    await getRepository(TwinSpace).delete({ domain: { id: domainId } as any, spaceId })
    return { ok: true }
  }

  /**
   * 이미 있는 트윈을 이 현장으로 가져온다 — **소속 갱신**(이력 이전이 아니다).
   *
   * 저널·투영 행은 `instanceId` 로 매여 있어 트윈을 따라오고, 구역·표현은 공간의 것이라 남는다
   * (근거·판정: `move-space.ts`). 그래서 이 뮤테이션이 쓰는 것은 두 곳뿐이다 —
   * 레지스트리의 `spaceId` 와 저장된 model 의 `spaceId`(커널·보드가 같은 공간을 가리켜야 한다).
   * 새 공간의 시간대로 `utcOffsetMinutes` 도 다시 파생한다(공간이 시간의 기준이다).
   *
   * `dryRun` 은 **같은 판정을 미리** 보여 준다 — 화면이 잃을 것을 먼저 말하고 사용자가 정한다.
   * 판정을 두 벌로 두면 미리보기와 실제가 어긋나므로 한 함수를 두 번 부른다.
   */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, {
    description:
      'Move an existing twin into a space (co-locate it as another lens). The journal and projected rows follow the twin; areas and representations stay with the old space. dryRun returns the same judgement without writing. Returns {ok, warnings, errorCode}.'
  })
  async moveTwinToSpace(
    @Arg('instanceId') instanceId: string,
    @Arg('spaceId') spaceId: string,
    @Ctx() context: ResolverContext,
    @Arg('dryRun', { nullable: true, description: 'Judge only — report refusal/warnings without moving.' }) dryRun?: boolean
  ): Promise<any> {
    const domainId = context.state.domain.id
    const instRepo = getRepository(TwinInstance)
    const spaceRepo = getRepository(TwinSpace)

    const inst = await instRepo.findOne({ where: { domain: { id: domainId }, instanceId } })
    const from = inst?.spaceId ? await spaceRepo.findOne({ where: { domain: { id: domainId }, spaceId: inst.spaceId } }) : null
    const to = await spaceRepo.findOne({ where: { domain: { id: domainId }, spaceId } })

    /* 판정에 필요한 사실만 모아 넘긴다 — 판정 자체는 순수 모듈이 한다. */
    const toAreaIds = to
      ? (await getRepository(TwinArea).find({ where: { domain: { id: domainId } as any, space: { id: to.id } as any } })).map(a => a.areaId)
      : []
    const fromRepresentationCount = from
      ? await getRepository(TwinSpaceRepresentation).count({ where: { domain: { id: domainId } as any, space: { id: from.id } as any } })
      : 0
    const model: any = inst?.model ?? {}
    const areaRefs: (string | undefined)[] = (model.locations ?? []).map((l: any) => l?.parentId)

    const judgement = judgeMoveTwinSpace({
      instanceId: inst?.instanceId,
      fromSpaceId: inst?.spaceId,
      toSpaceId: spaceId,
      toSpaceExists: !!to,
      purpose: (inst as any)?.purpose,
      running: !!inst && !!TwinEngine.runtime(domainId, instanceId),
      fromTimezone: from?.timezone ?? undefined,
      toTimezone: to?.timezone ?? undefined,
      areaRefs,
      toAreaIds,
      fromRepresentationCount
    })
    if (judgement.refusal) {
      const r = judgement.refusal
      return { ok: false, error: r.message, errorCode: r.code, errorParams: r.params, warnings: [] }
    }
    if (dryRun) return { ok: true, dryRun: true, warnings: judgement.warnings }

    /* 두 곳을 함께 쓴다 — 레지스트리와 model 이 다른 공간을 가리키면 보드·커널이 갈라진다. */
    const moved = { ...model, spaceId }
    const withTime = await TwinEngine.withSpaceTimeBase(moved, domainId, spaceId)
    await instRepo.save(instRepo.create({ ...(inst as any), spaceId, model: withTime }))

    /*
     * 감사 기록 — 소속을 바꾼 것은 사람의 결정이고, 나중에 "왜 이 트윈이 저 현장에 있나" 를 묻게 된다.
     * 기록이 실패해도 이전 결과는 돌려준다(감사가 본업을 막지 않는다). 다만 삼키지 않고 로그에 남긴다.
     */
    try {
      const repo = getRepository(TwinAuditEvent)
      await repo.save(
        repo.create({
          domain: context.state.domain,
          instanceId,
          commandType: 'twin.moveToSpace',
          accepted: true,
          origin: 'user',
          actorId: context.state.user?.id,
          args: { from: inst?.spaceId ?? null, to: spaceId, warnings: judgement.warnings.map(w => w.code) }
        } as any)
      )
    } catch (err) {
      twinError(`[twin-space] move audit not recorded for "${instanceId}"`, err)
    }

    return { ok: true, warnings: judgement.warnings }
  }

  /**
   * 트윈을 현장에서 뗀다 — **어느 현장에도 속하지 않음**으로 되돌린다.
   *
   * 더하기·옮기기만 있으면 잘못 넣은 것을 되돌릴 수 없다. 떼도 저널·로케이션·설비는 트윈에 남고
   * (`instanceId` 로 매여 있다), 구역·표현은 옛 현장에 남는다. 잃는 것은 **볼 무대**다 —
   * 판정이 그것을 말한다(`judgeDetachTwinSpace`). `dryRun` 은 같은 판정을 미리 낸다.
   */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, {
    description:
      'Detach a twin from its space (it ends up on no site). The journal and projected rows stay with the twin; areas and representations stay with the space. dryRun returns the same judgement without writing. Returns {ok, warnings, errorCode}.'
  })
  async detachTwinFromSpace(
    @Arg('instanceId') instanceId: string,
    @Ctx() context: ResolverContext,
    @Arg('dryRun', { nullable: true, description: 'Judge only — report refusal/warnings without detaching.' }) dryRun?: boolean
  ): Promise<any> {
    const domainId = context.state.domain.id
    const instRepo = getRepository(TwinInstance)
    const inst = await instRepo.findOne({ where: { domain: { id: domainId }, instanceId } })
    const from = inst?.spaceId
      ? await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId: inst.spaceId } })
      : null
    const fromRepresentationCount = from
      ? await getRepository(TwinSpaceRepresentation).count({ where: { domain: { id: domainId } as any, space: { id: from.id } as any } })
      : 0

    const judgement = judgeDetachTwinSpace({
      instanceId: inst?.instanceId,
      fromSpaceId: inst?.spaceId,
      purpose: (inst as any)?.purpose,
      fromRepresentationCount,
      fromTimezone: from?.timezone ?? undefined
    })
    if (judgement.refusal) {
      const r = judgement.refusal
      return { ok: false, error: r.message, errorCode: r.code, errorParams: r.params, warnings: [] }
    }
    if (dryRun) return { ok: true, dryRun: true, warnings: judgement.warnings }

    /* 두 곳을 함께 비운다 — 레지스트리와 model 이 어긋나면 어느 쪽이 사실인지 알 수 없다.
       시간 기준(utcOffsetMinutes)은 **남긴다**: 지우면 알리지 않고 UTC 로 읽힌다(판정이 그렇게 말했다). */
    const { spaceId: _dropped, ...model } = (inst?.model as any) ?? {}
    await instRepo.update({ id: (inst as any).id }, { spaceId: null as any, model })

    try {
      const repo = getRepository(TwinAuditEvent)
      await repo.save(
        repo.create({
          domain: context.state.domain,
          instanceId,
          commandType: 'twin.detachFromSpace',
          accepted: true,
          origin: 'user',
          actorId: context.state.user?.id,
          args: { from: inst?.spaceId ?? null, warnings: judgement.warnings.map(w => w.code) }
        } as any)
      )
    } catch (err) {
      twinError(`[twin-space] detach audit not recorded for "${instanceId}"`, err)
    }

    return { ok: true, warnings: judgement.warnings }
  }

  /**
   * 공간 ↔ 트윈 ↔ 가시화 정합성 점검 — **사실을 모아 순수 판정에 넘긴다.**
   *
   * 세 축은 서로를 id 로만 가리키고 DB 가 그 참조를 지켜 주지 않는다. 트윈을 옮기거나 떼거나 원본을
   * 다시 읽으면 아무 오류 없이 **가리킬 것이 없는 도형**과 **소속 없는 로케이션**이 남는다. 사람이
   * 눈으로 대조하던 일을 기계가 한다(판정·근거: `space-integrity.ts`).
   *
   * `spaceId` 를 주면 그 현장만, 없으면 테넌트 전체를 본다.
   */
  @Query(returns => [ScalarObject], {
    description:
      'Check space ↔ twin ↔ visualization integrity: dangling site refs, registry/model mismatch, polygons binding areas or entities that are not there, primary representation, unbound board representations. Pass spaceId to check one site.'
  })
  async twinSpaceIntegrity(
    @Ctx() context: ResolverContext,
    @Arg('spaceId', { nullable: true }) spaceId?: string
  ): Promise<any[]> {
    const domainId = context.state.domain.id
    const spaceRows = await getRepository(TwinSpace).find({ where: { domain: { id: domainId } } })
    const instRows = await getRepository(TwinInstance).find({ where: { domain: { id: domainId } } })
    const repRows = await getRepository(TwinSpaceRepresentation).find({ where: { domain: { id: domainId } }, relations: ['space'] })
    const areaRows = await getRepository(TwinArea).find({ where: { domain: { id: domainId } }, relations: ['space'] })
    const polyRows = await getRepository(TwinSpaceArea).find({ where: { domain: { id: domainId } }, relations: ['representation'] })

    const areasBySpace: Record<string, string[]> = {}
    for (const a of areaRows) {
      const sid = (a as any).space?.spaceId
      if (!sid) continue
      ;(areasBySpace[sid] ??= []).push(a.areaId)
    }

    /*
     * 폴리곤 바인딩의 실제 모양은 `{ groupId?, locationId?, locationIds? }` 다(지도 저작기 기준).
     * 여러 로케이션을 묶은 도형은 **각각을 따로** 본다 — 하나만 끊겨도 그 도형은 반쯤 거짓이 된다.
     */
    const polysByRep: Record<string, IntegrityPolygon[]> = {}
    for (const p of polyRows) {
      const rid = (p as any).representation?.id
      if (!rid) continue
      const b: any = p.binding ?? {}
      const list = polysByRep[rid] ??= []
      if (b.groupId) list.push({ id: p.id, groupId: b.groupId })
      const targets: string[] = [...(b.locationId ? [b.locationId] : []), ...(Array.isArray(b.locationIds) ? b.locationIds : [])]
      for (const t of targets) list.push({ id: p.id, targetKind: 'location', targetId: t })
    }

    /* 보드 id 는 표현 config 가 들고 있다 — 존재 확인은 보드 서비스의 일이므로, 여기서는 표현이
       가리키는 값이 있는지만 본다(없는 보드까지 보려면 board-service 를 물어야 한다: 아래 주석). */
    const boardIds = repRows.map(r => (r.config as any)?.boardId).filter(Boolean) as string[]

    const findings = checkSpaceIntegrity({
      spaces: spaceRows.map(s => ({ spaceId: s.spaceId, primaryRepresentationId: s.primaryRepresentationId })),
      instances: instRows.map(i => {
        const model: any = i.model ?? {}
        /*
         * 어휘가 맞는지는 **실행 중인 트윈만** 답할 수 있다 — 커널이 무엇을 버렸는지는 런타임의 사실이다.
         * 정지한 트윈은 `undefined`(모른다)로 둔다. 저널을 다시 계산해 알아내지는 않는다: 이 질의는
         * 테넌트 전체를 훑으므로 트윈마다 폴드를 걸면 정합성 점검이 가장 무거운 질의가 된다.
         */
        const live: any = TwinEngine.isRunning(domainId, i.instanceId)
          ? TwinEngine.snapshot(domainId, i.instanceId)
          : undefined
        return {
          instanceId: i.instanceId,
          spaceId: i.spaceId,
          modelSpaceId: model.spaceId,
          purpose: (i as any).purpose,
          locationIds: (model.locations ?? []).map((l: any) => l?.id).filter(Boolean),
          equipmentIds: (model.equipment ?? []).map((e: any) => e?.id).filter(Boolean),
          areaRefs: (model.locations ?? []).map((l: any) => l?.parentId),
          ...(Array.isArray(live?.unhandled) ? { unhandled: live.unhandled } : {})
        }
      }),
      representations: repRows.map(r => ({
        id: r.id,
        spaceId: (r as any).space?.spaceId ?? '',
        type: r.type,
        boardId: (r.config as any)?.boardId ?? null,
        polygons: polysByRep[r.id] ?? []
      })),
      areasBySpace,
      boardIds
    })

    const scoped = spaceId ? findings.filter(f => f.spaceId === spaceId || (!f.spaceId && !spaceId)) : findings
    return sortFindings(scoped)
  }

  /**
   * 기계적으로 고칠 수 있는 어긋남만 고친다 — **사람의 판단이 필요한 것은 손대지 않는다.**
   *
   * 지금 고치는 것은 하나다: **대표 표현 포인터**. 공간이 없는 표현 id 를 가리키고 있으면, 행의
   * `isPrimary` 가 켜진 표현(없으면 첫 표현)으로 다시 가리키고, 표현이 없으면 비운다. 근거가 있고
   * 답이 하나뿐인 부류라 자동으로 고쳐도 사실을 바꾸지 않는다.
   *
   * 폴리곤이 없는 구역·개체를 가리키는 것은 **고치지 않는다.** 그 도형을 지워야 하는지, 트윈을 다시
   * 데려와야 하는지, 구역을 다시 그려야 하는지는 사람이 정할 일이다 — 기계가 고르면 사용자가 그린
   * 도형이 오류 없이 사라진다.
   */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, {
    description:
      'Repair mechanically fixable space integrity findings (currently: a primary representation pointer that points nowhere). Dangling polygon bindings are left alone — that is a human decision. Returns {repaired:[{spaceId, code}], skipped}.'
  })
  async repairTwinSpaceIntegrity(
    @Ctx() context: ResolverContext,
    @Arg('spaceId', { nullable: true }) spaceId?: string
  ): Promise<any> {
    const domainId = context.state.domain.id
    const spaceRepo = getRepository(TwinSpace)
    const repRepo = getRepository(TwinSpaceRepresentation)
    const spaces = await spaceRepo.find({
      where: spaceId ? { domain: { id: domainId }, spaceId } : { domain: { id: domainId } }
    })
    const repaired: any[] = []
    for (const space of spaces) {
      const reps = await repRepo.find({ where: { domain: { id: domainId } as any, space: { id: space.id } as any }, order: { seq: 'ASC' } })
      const pointer = (space.primaryRepresentationId ?? '').trim()
      if (pointer && reps.some(r => r.id === pointer)) continue /* 이미 옳다 */
      const primary = reps.find(r => r.isPrimary) ?? reps[0]
      const next = primary?.id ?? null
      if (pointer === (next ?? '')) continue
      await spaceRepo.save(spaceRepo.create({ ...space, primaryRepresentationId: next }))
      if (primary) for (const r of reps) if (!!r.isPrimary !== (r.id === primary.id)) await repRepo.save(repRepo.create({ ...r, isPrimary: r.id === primary.id }))
      repaired.push({ spaceId: space.spaceId, code: 'primary-representation-missing', from: pointer || null, to: next })
    }
    return { ok: true, repaired, count: repaired.length }
  }

  /* ── Area(논리 구역, 표현 무관·공유·계층) — area 단일화 space #2 ─────── */
  @Query(returns => [ScalarObject], { description: 'List logical areas (representation-agnostic hierarchy) of a space. (area unification)' })
  async twinAreas(@Arg('spaceId') spaceId: string, @Ctx() context: ResolverContext): Promise<any[]> {
    const domainId = context.state.domain.id
    const rows = await getRepository(TwinArea).find({ where: { domain: { id: domainId }, space: { spaceId } }, order: { createdAt: 'ASC' } })
    return rows.map(a => ({ areaId: a.areaId, name: a.name, type: a.type, parentId: a.parentId, layout: a.layout }))
  }

  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Create/update a logical area (shared across representations). (area unification)' })
  async saveTwinArea(
    @Arg('spaceId') spaceId: string,
    @Arg('areaId') areaId: string,
    @Arg('patch', type => ScalarObject) patch: any,
    @Ctx() context: ResolverContext
  ): Promise<boolean> {
    const domainId = context.state.domain.id
    const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
    if (!space) throw new Error(`space "${spaceId}" not found`)
    const repo = getRepository(TwinArea)
    const existing = await repo.findOne({ where: { domain: { id: domainId }, space: { id: space.id }, areaId } })
    await repo.save(
      repo.create({
        ...(existing ?? {}),
        domain: { id: domainId } as any,
        space: { id: space.id } as any,
        areaId,
        name: patch?.name ?? existing?.name ?? areaId,
        type: patch?.type ?? existing?.type,
        parentId: patch?.parentId !== undefined ? patch.parentId : existing?.parentId,
        layout: patch?.layout ?? existing?.layout
      })
    )
    return true
  }

  /*
   * 참조기반 회수(reference-counted) — area 는 참조가 남아 있으면 삭제 차단, 고아면 제거.
   * 참조: 자식 area(parentId) · 표현별 폴리곤(TwinSpaceArea binding.groupId/areaId).
   * (노드/엔티티 담김·drillTo 참조는 P2 areaId 배선 후 확장.)
   */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Delete a logical area only if unreferenced (reference-counted). Throws if referenced. (area unification)' })
  async deleteTwinArea(@Arg('spaceId') spaceId: string, @Arg('areaId') areaId: string, @Ctx() context: ResolverContext): Promise<boolean> {
    const domainId = context.state.domain.id
    const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
    if (!space) return false
    // 참조 1: 자식 area
    const children = await getRepository(TwinArea).count({ where: { domain: { id: domainId }, space: { id: space.id }, parentId: areaId } })
    // 참조 2: 표현별 폴리곤(이 공간의 표현들에 이 area 를 그린 것). binding.groupId/areaId 는 JSON → 로드 후 JS 필터(멀티DB).
    const reps = await getRepository(TwinSpaceRepresentation).find({ where: { domain: { id: domainId }, space: { id: space.id } } })
    let polygonRefs = 0
    for (const rep of reps) {
      const polys = await getRepository(TwinSpaceArea).find({ where: { domain: { id: domainId }, representation: { id: rep.id } } })
      polygonRefs += polys.filter(p => (p.binding as any)?.groupId === areaId || (p.binding as any)?.areaId === areaId).length
    }
    if (children > 0 || polygonRefs > 0) {
      throw new Error(`deleteArea: area "${areaId}" cannot be deleted due to existing references (children: ${children}, polygonRefs: ${polygonRefs}). Remove references first.`)
    }
    await getRepository(TwinArea).delete({ domain: { id: domainId } as any, space: { id: space.id } as any, areaId })
    return true
  }

  /* ── Representation ─────────────────────────────────────────────── */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, { description: 'Create/update a representation (map|image|model). Returns {id}.' })
  async saveSpaceRepresentation(
    @Arg('spaceId') spaceId: string,
    @Arg('rep', type => ScalarObject) rep: any,
    @Ctx() context: ResolverContext
  ): Promise<any> {
    const domainId = context.state.domain.id
    const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId }, spaceId } })
    if (!space) return { ok: false, error: `space not found: ${spaceId}` }
    const repo = getRepository(TwinSpaceRepresentation)
    const existing = rep?.id ? await repo.findOne({ where: { id: rep.id } }) : null
    /*
     * `role` 은 닫힌 값이다 — 모르는 값을 그냥 저장하면 화면이 그것을 어느 쪽으로도 그리지 못하고,
     * 그 표현이 목록에서 오류 없이 사라진다. 비어 있는 것은 `index` 를 뜻하므로 그대로 둔다.
     */
    const role = rep.role == null || String(rep.role).trim() === '' ? undefined : String(rep.role).trim()
    if (role && !(REPRESENTATION_ROLES as readonly string[]).includes(role)) {
      return { ok: false, error: `unknown representation role "${role}" — one of: ${REPRESENTATION_ROLES.join(', ')}` }
    }
    /* 묶는 이름은 자유 문자열이다. 다만 공백만 있는 값은 「묶이지 않음」과 같으므로 비운다. */
    const group = rep.group == null || String(rep.group).trim() === '' ? undefined : String(rep.group).trim()

    const saved = await repo.save(
      repo.create({
        ...(existing ?? {}),
        domain: { id: domainId } as any,
        space: { id: space.id } as any,
        type: rep.type,
        name: rep.name,
        seq: rep.seq ?? 0,
        isPrimary: !!rep.isPrimary,
        config: rep.config,
        group: group ?? null,
        role: role ?? null
      } as Partial<TwinSpaceRepresentation>)
    )
    return { ok: true, id: saved.id }
  }

  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Delete a representation and its areas.' })
  async deleteSpaceRepresentation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
    const domainId = context.state.domain.id
    await getRepository(TwinSpaceArea).delete({ domain: { id: domainId } as any, representation: { id } as any })
    await getRepository(TwinSpaceRepresentation).delete({ domain: { id: domainId } as any, id } as any)
    return true
  }

  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Set the primary representation of a space.' })
  async setPrimaryRepresentation(@Arg('spaceId') spaceId: string, @Arg('repId') repId: string, @Ctx() context: ResolverContext): Promise<boolean> {
    const domainId = context.state.domain.id
    const spaceRepo = getRepository(TwinSpace)
    const space = await spaceRepo.findOne({ where: { domain: { id: domainId }, spaceId } })
    if (!space) return false
    await spaceRepo.save(spaceRepo.create({ ...space, primaryRepresentationId: repId }))
    const repRepo = getRepository(TwinSpaceRepresentation)
    const reps = await repRepo.find({ where: { domain: { id: domainId }, space: { id: space.id } } })
    for (const rep of reps) if (!!rep.isPrimary !== (rep.id === repId)) await repRepo.save(repRepo.create({ ...rep, isPrimary: rep.id === repId }))
    return true
  }

  /* ── Area (map/image 폴리곤) ────────────────────────────────────── */
  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => ScalarObject, { description: 'Create/update a polygon area (geometry + drillTo model + binding). Returns {id}.' })
  async saveSpaceArea(
    @Arg('representationId') representationId: string,
    @Arg('area', type => ScalarObject) area: any,
    @Ctx() context: ResolverContext
  ): Promise<any> {
    const domainId = context.state.domain.id
    const repo = getRepository(TwinSpaceArea)
    const existing = area?.id ? await repo.findOne({ where: { id: area.id } }) : null
    /* drillTo/binding 은 선택적 링크 — 클라가 해제(undefined)로 보내면 JSON 에서 키가 빠져 TypeORM 이 "변경 없음"으로
     * 무시하므로 기존 값이 남는다. null 로 강제해 명시적으로 컬럼을 비운다(저장은 늘 전체 필드를 보냄 → 덮어쓰기 안전). */
    const saved = await repo.save(repo.create({ ...(existing ?? {}), domain: { id: domainId } as any, representation: { id: representationId } as any, name: area.name, type: area.type, geometry: area.geometry, drillTo: area.drillTo ?? null, binding: area.binding ?? null, style: area.style }))
    return { ok: true, id: saved.id }
  }

  @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
  @Mutation(returns => Boolean, { description: 'Delete a polygon area.' })
  async deleteSpaceArea(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
    await getRepository(TwinSpaceArea).delete({ domain: { id: context.state.domain.id } as any, id } as any)
    return true
  }
}