cohortEditLogic.ts

import {
    actions,
    afterMount,
    beforeUnmount,
    connect,
    isBreakpoint,
    kea,
    key,
    listeners,
    path,
    props,
    reducers,
    selectors,
} from 'kea'
import { forms } from 'kea-forms'
import { loaders } from 'kea-loaders'
import { actionToUrl, router, urlToAction } from 'kea-router'
import posthog from 'posthog-js'
import { v4 as uuidv4 } from 'uuid'

import api from 'lib/api'
import { ApiError } from 'lib/api-error'
import { tryShowMCPHint } from 'lib/components/MCPHint/mcpHintLogic'
import { SetupTaskId, globalSetupLogic } from 'lib/components/ProductSetup'
import { ENTITY_MATCH_TYPE } from 'lib/constants'
import { scrollToFormError } from 'lib/forms/scrollToFormError'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { isOperatorDate } from 'lib/utils'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'
import { NEW_COHORT, NEW_CRITERIA, NEW_CRITERIA_GROUP } from 'scenes/cohorts/CohortFilters/constants'
import { BehavioralFilterKey } from 'scenes/cohorts/CohortFilters/types'
import {
    applyAllCriteriaGroup,
    applyAllNestedCriteria,
    cleanCriteria,
    createCohortDataNodeLogicKey,
    createCohortFormData,
    isCohortCriteriaGroup,
    validateGroup,
} from 'scenes/cohorts/cohortUtils'
import { personsLogic } from 'scenes/persons/personsLogic'
import { teamLogic } from 'scenes/teamLogic'
import { urls } from 'scenes/urls'

import { refreshTreeItem } from '~/layout/panel-layout/ProjectTree/projectTreeLogic'
import { cohortsModel, processCohort } from '~/models/cohortsModel'
import { propertyDefinitionsModel } from '~/models/propertyDefinitionsModel'
import { dataNodeLogic } from '~/queries/nodes/DataNode/dataNodeLogic'
import { ActorsQuery, DataTableNode, HogQLQuery, Node, NodeKind } from '~/queries/schema/schema-general'
import { isDataTableNode } from '~/queries/utils'
import {
    AnyCohortCriteriaType,
    AnyCohortGroupType,
    CohortCriteriaGroupFilter,
    CohortGroupType,
    CohortType,
    FilterLogicalOperator,
    PropertyDefinitionType,
    PropertyFilterType,
    PropertyOperator,
    PropertyType,
} from '~/types'

import { cohortsUsedInRetrieve } from 'products/cohorts/frontend/generated/api'
import type { CohortUsedInResponseApi } from 'products/cohorts/frontend/generated/api.schemas'

import type { cohortEditLogicType } from './cohortEditLogicType'

export type CohortLogicProps = {
    id?: CohortType['id']
}

export type StaticCohortMode = 'criteria' | 'people'

export type CohortEditTab = 'overview' | 'history'

const isCohortEditTab = (value: unknown): value is CohortEditTab => value === 'overview' || value === 'history'

const checkIsPendingCalculation = (cohort: CohortType): boolean =>
    cohort.pending_version != null && (cohort.version == null || cohort.pending_version !== cohort.version)

const hasFilterCriteria = (cohort: CohortType): boolean =>
    Array.isArray(cohort.filters?.properties?.values) && cohort.filters.properties.values.length > 0

const inferStaticCohortMode = (cohort: CohortType): StaticCohortMode =>
    cohort.id === 'new' || cohort.id == null
        ? 'people'
        : cohort.is_static && hasFilterCriteria(cohort)
          ? 'criteria'
          : 'people'

export const cohortEditLogic = kea<cohortEditLogicType>([
    props({} as CohortLogicProps),
    key((props) => (props.id === 'new' || !props.id ? 'new' : props.id)),
    path(['scenes', 'cohorts', 'cohortLogicEdit']),
    connect(() => ({
        values: [teamLogic, ['currentProjectId']],
        actions: [eventUsageLogic, ['reportExperimentExposureCohortEdited']],
        logic: [cohortsModel],
    })),

    actions({
        saveCohort: (cohortParams = {}) => ({ cohortParams }),
        setCohort: (cohort: CohortType) => ({ cohort }),
        deleteCohort: true,
        restoreCohort: true,
        fetchCohort: (id: CohortType['id']) => ({ id }),
        setCohortMissing: true,
        onCriteriaChange: (newGroup: Partial<CohortGroupType>, id: string) => ({ newGroup, id }),
        setPollTimeout: (pollTimeout: number | null) => ({ pollTimeout }),
        checkIfFinishedCalculating: (cohort: CohortType) => ({ cohort }),

        setOuterGroupsType: (type: FilterLogicalOperator) => ({ type }),
        setInnerGroupType: (type: FilterLogicalOperator, groupIndex: number) => ({ type, groupIndex }),
        duplicateFilter: (groupIndex: number, criteriaIndex?: number) => ({ groupIndex, criteriaIndex }),
        addFilter: (groupIndex?: number) => ({ groupIndex }),
        removeFilter: (groupIndex: number, criteriaIndex?: number) => ({ groupIndex, criteriaIndex }),
        setCriteria: (newCriteria: AnyCohortCriteriaType, groupIndex: number, criteriaIndex: number) => ({
            newCriteria,
            groupIndex,
            criteriaIndex,
        }),
        setQuery: (query: Node) => ({ query }),
        duplicateCohort: (asStatic: boolean) => ({ asStatic }),
        updateCohortCount: true,
        setCreationPersonQuery: (query: ActorsQuery) => ({ query }),
        addPersonToCreateStaticCohort: (personId: string) => ({ personId }),
        removePersonFromCreateStaticCohort: (personId: string) => ({ personId }),
        removePersonFromCohort: (personId: string) => ({ personId }),
        resetPersonsToCreateStaticCohort: true,
        refreshPersonsData: true,
        setStaticCohortMode: (mode: StaticCohortMode) => ({ mode }),
        setActiveTab: (tab: CohortEditTab) => ({ tab }),
    }),

    reducers(({ props }) => ({
        cohort: [
            NEW_COHORT,
            {
                setOuterGroupsType: (state, { type }) => ({
                    ...state,
                    filters: {
                        properties: {
                            ...state.filters.properties,
                            type,
                        },
                    },
                }),
                setInnerGroupType: (state, { type, groupIndex }) =>
                    applyAllCriteriaGroup(
                        state,
                        (groupList) =>
                            groupList.map((group, groupI) =>
                                groupI === groupIndex ? { ...group, type } : group
                            ) as CohortCriteriaGroupFilter[]
                    ),
                duplicateFilter: (state, { groupIndex, criteriaIndex }) => {
                    if (criteriaIndex !== undefined) {
                        return applyAllNestedCriteria(
                            state,
                            (criteriaList) => [
                                ...criteriaList.slice(0, criteriaIndex),
                                {
                                    ...criteriaList[criteriaIndex],
                                    sort_key: uuidv4(),
                                },
                                ...criteriaList.slice(criteriaIndex),
                            ],
                            groupIndex
                        )
                    }
                    return applyAllCriteriaGroup(state, (groupList) => [
                        ...groupList.slice(0, groupIndex),
                        {
                            ...groupList[groupIndex],
                            sort_key: uuidv4(),
                        },
                        ...groupList.slice(groupIndex),
                    ])
                },
                addFilter: (state, { groupIndex }) => {
                    if (groupIndex !== undefined) {
                        return applyAllNestedCriteria(
                            state,
                            (criteriaList) => [...criteriaList, { ...NEW_CRITERIA, sort_key: uuidv4() }],
                            groupIndex
                        )
                    }
                    return applyAllCriteriaGroup(state, (groupList) => [
                        ...groupList,
                        { ...NEW_CRITERIA_GROUP, sort_key: uuidv4() },
                    ])
                },
                removeFilter: (state, { groupIndex, criteriaIndex }) => {
                    if (criteriaIndex !== undefined) {
                        return applyAllNestedCriteria(
                            state,
                            (criteriaList) => [
                                ...criteriaList.slice(0, criteriaIndex),
                                ...criteriaList.slice(criteriaIndex + 1),
                            ],
                            groupIndex
                        )
                    }
                    return applyAllCriteriaGroup(state, (groupList) => [
                        ...groupList.slice(0, groupIndex),
                        ...groupList.slice(groupIndex + 1),
                    ])
                },
                setCriteria: (state, { newCriteria, groupIndex, criteriaIndex }) =>
                    applyAllNestedCriteria(
                        state,
                        (criteriaList) =>
                            criteriaList.map((oldCriteria, criteriaI) =>
                                isCohortCriteriaGroup(oldCriteria)
                                    ? oldCriteria
                                    : criteriaI === criteriaIndex
                                      ? cleanCriteria({ ...oldCriteria, ...newCriteria })
                                      : oldCriteria
                            ),
                        groupIndex
                    ),
            },
        ],
        cohortMissing: [
            false,
            {
                setCohortMissing: () => true,
            },
        ],
        pollTimeout: [
            null as number | null,
            {
                setPollTimeout: (_, { pollTimeout }) => pollTimeout,
            },
        ],
        query: [
            {
                kind: NodeKind.DataTableNode,
                source: {
                    kind: NodeKind.ActorsQuery,
                    fixedProperties: [
                        { type: PropertyFilterType.Cohort, key: 'id', value: parseInt(String(props.id)) },
                    ],
                },
                full: true,
                showPropertyFilter: false,
                showEventFilter: false,
                ...(props.id && props.id !== 'new'
                    ? { showPersistentColumnConfigurator: true, contextKey: `cohort:${props.id}` }
                    : {}),
            } as DataTableNode,
            {
                setQuery: (state, { query }) => (isDataTableNode(query) ? query : state),
                setCohort: (state, { cohort }) => {
                    const source = state.source as ActorsQuery
                    const defaultSelect = cohort.is_static
                        ? ['person_display_name -- Person', 'id', 'created_at', 'person.$delete']
                        : ['person_display_name -- Person', 'id', 'created_at']
                    return {
                        ...state,
                        source: {
                            ...source,
                            select: source.select ?? defaultSelect,
                        },
                    }
                },
            },
        ],
        creationPersonQuery: [
            {
                kind: NodeKind.ActorsQuery,
                fixedProperties: [],
                select: ['id', 'person_display_name -- Person'],
            } as ActorsQuery,
            {
                setCreationPersonQuery: (_state, { query }) => query,
            },
        ],
        personsToCreateStaticCohort: [
            {} as Record<string, boolean>,
            {
                addPersonToCreateStaticCohort: (state, { personId }) => ({
                    ...state,
                    [personId]: true,
                }),
                removePersonFromCreateStaticCohort: (state, { personId }) => {
                    const newState = { ...state }
                    delete newState[personId]
                    return newState
                },
                resetPersonsToCreateStaticCohort: () => ({}),
            },
        ],
        staticCohortMode: [
            'people' as StaticCohortMode,
            {
                setCohort: (_, { cohort }) => inferStaticCohortMode(cohort),
                setStaticCohortMode: (_, { mode }) => mode,
            },
        ],
        activeTab: [
            'overview' as CohortEditTab,
            {
                setActiveTab: (_, { tab }) => tab,
            },
        ],
    })),

    selectors({
        canRemovePersonFromCohort: [
            (s) => [s.cohort],
            (cohort: CohortType) => {
                return cohort.is_static && typeof cohort.id === 'number'
            },
        ],
        isPendingCalculation: [(s) => [s.cohort], (cohort: CohortType) => checkIsPendingCalculation(cohort)],
        isCalculatingOrPending: [
            (s) => [s.cohort, s.isPendingCalculation],
            (cohort: CohortType, isPendingCalculation: boolean) => {
                return cohort.is_calculating || isPendingCalculation
            },
        ],
    }),

    forms(({ actions, values }) => ({
        cohort: {
            defaults: NEW_COHORT,
            errors: ({ name, is_static, filters }) => ({
                name: !name ? 'Cohort name cannot be empty' : undefined,
                csv: undefined,
                filters: {
                    properties: {
                        values:
                            is_static && values.staticCohortMode !== 'criteria'
                                ? undefined
                                : filters.properties.values.map(validateGroup),
                    },
                },
            }),
            submit: (cohort) => {
                // Prevent multiple concurrent saves
                if (values.cohortLoading) {
                    return
                }

                if (cohort.id !== 'new') {
                    actions.saveCohort(cohort)
                } else {
                    const personIds = Object.keys(values.personsToCreateStaticCohort)
                    if (
                        cohort.is_static &&
                        values.staticCohortMode === 'people' &&
                        cohort.csv == null &&
                        personIds.length === 0
                    ) {
                        lemonToast.error('You need to upload a csv file or add a person manually.')
                        return
                    }
                    if (
                        cohort.is_static &&
                        values.staticCohortMode === 'criteria' &&
                        !((cohort.filters?.properties as Record<string, any>)?.values?.length > 0)
                    ) {
                        lemonToast.error('You need to add at least one filter criterion.')
                        return
                    }
                    actions.saveCohort({
                        ...cohort,
                        _create_in_folder: 'Unfiled/Cohorts',
                        _create_static_person_ids: personIds.length > 0 ? personIds : undefined,
                    })
                }
            },
        },
    })),

    loaders(({ actions, values, key, props }) => ({
        cohort: [
            NEW_COHORT,
            {
                setCohort: ({ cohort }) => processCohort(cohort),
                fetchCohort: async ({ id }, breakpoint) => {
                    try {
                        const cohort = await api.cohorts.get(id)
                        breakpoint()
                        cohortsModel.actions.updateCohort(cohort)
                        actions.setCohort(cohort)
                        actions.checkIfFinishedCalculating(cohort)
                        return processCohort(cohort)
                    } catch (error: any) {
                        lemonToast.error(error.detail || 'Failed to fetch cohort')

                        actions.setCohortMissing()
                        return values.cohort
                    }
                },
                restoreCohort: async () => {
                    try {
                        const restoredCohort = await api.cohorts.update(values.cohort.id, {
                            deleted: false,
                        })
                        actions.setCohort(restoredCohort)
                        lemonToast.success('Cohort restored successfully.')
                        return restoredCohort
                    } catch (error) {
                        lemonToast.error(`Failed to restore cohort: '${error}'`)
                        return values.cohort
                    }
                },
                saveCohort: async ({ cohortParams }, breakpoint) => {
                    const existingCohort = values.cohort
                    let cohort = { ...existingCohort, ...cohortParams }
                    const cohortFormData = createCohortFormData(cohort, {
                        preserveStaticFilters: cohort.is_static && values.staticCohortMode === 'criteria',
                    })

                    try {
                        if (cohort.id !== 'new') {
                            cohort = await api.cohorts.update(cohort.id, cohortFormData as Partial<CohortType>)
                            cohortsModel.actions.updateCohort(cohort)

                            if (cohort.experiment_set && cohort.experiment_set.length > 0) {
                                // someone edited an exposure cohort. Track what kind of updates were made
                                actions.reportExperimentExposureCohortEdited(existingCohort, cohort)
                            }
                        } else {
                            cohort = await api.cohorts.create(cohortFormData as Partial<CohortType>)
                            cohortsModel.actions.cohortCreated(cohort)
                            globalSetupLogic.findMounted()?.actions.markTaskAsCompleted(SetupTaskId.SetUpCohorts)
                        }
                    } catch (error: any) {
                        breakpoint()

                        // Only capture exception if we don't have proper error details
                        // This indicates an unexpected failure (network, timeout, etc.)
                        if (!error.detail) {
                            console.error('Cohort creation failed unexpectedly:', error, {
                                cohort_name: cohort.name,
                                operation_type: cohort.id === 'new' ? 'create' : 'update',
                                is_static: cohort.is_static,
                            })
                            posthog.captureException(error, {
                                cohort_operation: 'Cohort creation failed unexpectedly',
                                // Cohort context (most valuable)
                                cohort_name: cohort.name,
                                is_static: cohort.is_static,
                                operation_type: cohort.id === 'new' ? 'create' : 'update',
                                has_csv: !!cohortFormData.get?.('csv'),
                                file_size: (() => {
                                    const csvFile = cohortFormData.get?.('csv')
                                    return csvFile instanceof File ? csvFile.size : undefined
                                })(),

                                // Error context
                                error_status: error.status,
                                error_status_text: error.statusText,
                                error_message: error.message,
                                error_name: error.name,
                                error_type: typeof error,

                                // Browser context
                                user_agent: navigator.userAgent.substring(0, 100),
                                is_online: navigator.onLine,

                                // Request context
                                timestamp: new Date().toISOString(),
                            })
                        }

                        lemonToast.error(error.detail || 'Failed to save cohort')
                        return values.cohort
                    }

                    cohort.is_calculating = true // this will ensure there is always a polling period to allow for backend calculation task to run
                    breakpoint()

                    delete cohort['csv']
                    actions.setCohort(cohort)
                    refreshTreeItem('cohort', cohort.id)
                    lemonToast.success('Cohort saved. Please wait up to a few minutes for it to be calculated', {
                        toastId: `cohort-saved-${key}`,
                    })
                    actions.checkIfFinishedCalculating(cohort)
                    if (existingCohort.id === 'new') {
                        tryShowMCPHint('cohorts.create', {
                            derivedPrompt: cohort.name ? `Build a cohort called ${cohort.name}` : undefined,
                        })
                    }
                    if (cohort.id !== 'new') {
                        actions.refreshPersonsData()
                    }
                    if (existingCohort.id === 'new') {
                        router.actions.push(urls.cohort(cohort.id))
                        if (existingCohort.is_static) {
                            actions.resetPersonsToCreateStaticCohort()
                        }
                        return { ...NEW_COHORT }
                    }
                    return processCohort(cohort)
                },
                onCriteriaChange: ({ newGroup, id }) => {
                    const cohort = { ...values.cohort }
                    const index = cohort.groups.findIndex((group: AnyCohortGroupType) => group.id === id)
                    if (newGroup.matchType) {
                        cohort.groups[index] = {
                            id: cohort.groups[index].id,
                            matchType: ENTITY_MATCH_TYPE,
                            ...newGroup,
                        }
                    } else {
                        cohort.groups[index] = {
                            ...cohort.groups[index],
                            ...newGroup,
                        }
                    }
                    return processCohort(cohort)
                },
                updateCohortCount: async () => {
                    const cohort = await api.cohorts.get(values.cohort.id)
                    return {
                        ...values.cohort,
                        count: cohort.count,
                    }
                },
            },
        ],
        duplicatedCohort: [
            null as CohortType | null,
            {
                duplicateCohort: async ({ asStatic }: { asStatic: boolean }, breakpoint) => {
                    let cohort: CohortType
                    try {
                        await breakpoint(200)
                        if (asStatic) {
                            const sourceTable = values.cohort.is_static ? 'static_cohort_people' : 'cohort_people'
                            const query: HogQLQuery = {
                                kind: NodeKind.HogQLQuery,
                                query: `SELECT person_id FROM ${sourceTable} WHERE cohort_id = ${values.cohort.id}`,
                            }
                            cohort = await api.create('api/cohort', {
                                is_static: true,
                                name: `${values.cohort.name} (static copy)`,
                                query,
                            })
                        } else {
                            const data = { ...values.cohort }
                            data.name += ' (dynamic copy)'
                            const cohortFormData = createCohortFormData(data)
                            cohort = await api.cohorts.create(cohortFormData as Partial<CohortType>)
                        }
                        lemonToast.success(
                            'Cohort duplicated. Please wait up to a few minutes for it to be calculated',
                            {
                                toastId: `cohort-duplicated-${cohort.id}`,
                                button: {
                                    label: 'View cohort',
                                    action: () => {
                                        router.actions.push(urls.cohort(cohort.id))
                                    },
                                },
                            }
                        )
                        return cohort
                    } catch (error: any) {
                        lemonToast.error(error.detail || 'Failed to duplicate cohort')
                        return null
                    }
                },
            },
        ],

        removePersonFromCohort: [
            null as any,
            {
                removePersonFromCohort: async ({ personId }) => {
                    if (!values.cohort.id || values.cohort.id === 'new') {
                        throw new Error('Cannot remove person from unsaved cohort')
                    }

                    try {
                        await api.cohorts.removePersonFromCohort(values.cohort.id, personId)
                        lemonToast.success('Person removed from cohort')
                    } catch (error: any) {
                        throw error
                    }
                    // Refresh cohort data + count
                    actions.refreshPersonsData()
                    actions.updateCohortCount()
                },
            },
        ],

        usedIn: [
            null as CohortUsedInResponseApi | null,
            {
                loadUsedIn: async () => {
                    // On mount `values.cohort` is still NEW_COHORT (fetchCohort hasn't resolved),
                    // so fall back to the id from props.
                    const id = values.cohort.id !== 'new' ? values.cohort.id : props.id
                    if (!id || id === 'new') {
                        return null
                    }
                    try {
                        return await cohortsUsedInRetrieve(String(values.currentProjectId), Number(id))
                    } catch (error) {
                        // A 404 just means the endpoint isn't deployed yet (deploy skew) or the
                        // cohort is gone; neither is worth reporting.
                        if (!(error instanceof ApiError) || error.status !== 404) {
                            posthog.captureException(error, { feature: 'cohort-used-in' })
                        }
                        return null
                    }
                },
            },
        ],
    })),
    listeners(({ actions, values }) => ({
        setCriteria: ({ newCriteria, groupIndex, criteriaIndex }) => {
            // When the person property key changes, auto-reset the operator to match the
            // property type (DateTime → "on the date", non-DateTime → "equals").
            if (!('key' in newCriteria)) {
                return
            }

            const groups = values.cohort.filters.properties.values
            const group = groups[groupIndex]
            if (!isCohortCriteriaGroup(group)) {
                return
            }
            const criteria = group.values[criteriaIndex]
            if (!criteria || isCohortCriteriaGroup(criteria)) {
                return
            }

            if (criteria.type !== BehavioralFilterKey.Person) {
                return
            }

            const propDef = newCriteria.key
                ? propertyDefinitionsModel
                      .findMounted()
                      ?.values.getPropertyDefinition(newCriteria.key, PropertyDefinitionType.Person)
                : null
            const isDateTime = propDef?.property_type === PropertyType.DateTime
            const currentOperator = criteria.operator as PropertyOperator | undefined

            if (isDateTime && (!currentOperator || !isOperatorDate(currentOperator))) {
                actions.setCriteria({ operator: PropertyOperator.IsDateExact }, groupIndex, criteriaIndex)
            } else if (!isDateTime && currentOperator && isOperatorDate(currentOperator)) {
                actions.setCriteria({ operator: PropertyOperator.Exact }, groupIndex, criteriaIndex)
            }
        },
        deleteCohort: () => {
            cohortsModel.actions.deleteCohort({ id: values.cohort.id, name: values.cohort.name })
        },
        submitCohortFailure: () => {
            scrollToFormError({
                extraErrorSelectors: ['.CohortCriteriaRow__Criteria--error'],
                fallbackErrorMessage:
                    'There was an error submitting this cohort. Make sure the cohort filters are correct.',
            })
        },
        // Refresh once the save request actually resolves; submitCohortSuccess fires as soon
        // as the synchronous submit handler dispatches saveCohort.
        saveCohortSuccess: () => {
            actions.loadUsedIn()
        },
        checkIfFinishedCalculating: async ({ cohort }, breakpoint) => {
            const isPendingCalculation = checkIsPendingCalculation(cohort)
            const isCalculatingOrPending = cohort.is_calculating || isPendingCalculation

            if (isCalculatingOrPending) {
                actions.setPollTimeout(
                    window.setTimeout(async () => {
                        try {
                            const newCohort = await api.cohorts.get(cohort.id)
                            // breakpoint() throws to abort once the logic unmounts. Because this runs
                            // in a detached setTimeout callback (not the listener body), that throw
                            // would otherwise surface as an unhandled rejection — keep it contained.
                            breakpoint()
                            actions.checkIfFinishedCalculating(newCohort)
                        } catch (e: any) {
                            if (!isBreakpoint(e)) {
                                throw e
                            }
                            // Poll superseded or logic unmounted — stop quietly.
                        }
                    }, 1000)
                )
            } else {
                // Only update calculation-related fields, preserve user edits for other fields
                const calculationFields = {
                    is_calculating: cohort.is_calculating,
                    errors_calculating: cohort.errors_calculating,
                    last_calculation: cohort.last_calculation,
                    count: cohort.count,
                    version: cohort.version,
                    pending_version: cohort.pending_version,
                }
                actions.setCohort({ ...values.cohort, ...calculationFields })
                cohortsModel.actions.updateCohort(cohort)
                personsLogic.findMounted({ syncWithUrl: true })?.actions.loadCohorts() // To ensure sync on person page
                actions.refreshPersonsData()
                if (values.pollTimeout) {
                    clearTimeout(values.pollTimeout)
                    actions.setPollTimeout(null)
                }
            }
        },
        refreshPersonsData: async (_, breakpoint) => {
            await breakpoint(100)
            // Refresh the persons data table
            const dataNodeLogicKey = createCohortDataNodeLogicKey(values.cohort.id)
            dataNodeLogic.findMounted({ key: dataNodeLogicKey })?.actions.loadData('force_blocking')
        },
    })),

    actionToUrl(({ values }) => ({
        setActiveTab: () => {
            const { tab: _, ...restHash } = router.values.hashParams
            const nextHash = values.activeTab === 'overview' ? restHash : { ...restHash, tab: values.activeTab }
            return [router.values.location.pathname, router.values.searchParams, nextHash, { replace: true }]
        },
    })),

    urlToAction(({ actions, values }) => ({
        '/cohorts/:id': (_, __, { tab }) => {
            const next = isCohortEditTab(tab) ? tab : 'overview'
            if (values.activeTab !== next) {
                actions.setActiveTab(next)
            }
        },
    })),

    afterMount(({ actions, props, values }) => {
        if (!props.id || props.id === 'new') {
            actions.setCohort(NEW_COHORT)
            // Tabs aren't shown for new cohorts; clear any stale `#tab=…` hash so the URL reflects reality
            // and reset the in-memory tab so the Overview content (the only thing rendered for new cohorts)
            // is actually visible — otherwise the user lands on a blank page.
            if (router.values.hashParams.tab) {
                const { tab: _, ...restHash } = router.values.hashParams
                router.actions.replace(router.values.location.pathname, router.values.searchParams, restHash)
            }
            if (values.activeTab !== 'overview') {
                actions.setActiveTab('overview')
            }
        } else {
            actions.fetchCohort(props.id)
            actions.loadUsedIn()
        }
    }),
    beforeUnmount(({ values }) => {
        if (values.pollTimeout) {
            clearTimeout(values.pollTimeout)
        }
    }),
])