/**
 * Vim Operator Functions
 *
 * Pure functions for executing vim operators (delete, change, yank, etc.)
 */

import { Cursor } from '../utils/Cursor.js'
import { firstGrapheme, lastGrapheme } from '../utils/intl.js'
import { countCharInString } from '../utils/stringUtils.js'
import {
 isInclusiveMotion,
 isLinewiseMotion,
 resolveMotion,
} from './motions.js'
import { findTextObject } from './textObjects.js'
import type {
 FindType,
 Operator,
 RecordedChange,
 TextObjScope,
} from './types.js'

/**
 * Context for operator execution.
 */
export type OperatorContext = {
 cursor: Cursor
 text: string
 setText: (text: string) => void
 setOffset: (offset: number) => void
 enterInsert: (offset: number) => void
 getRegister: () => string
 setRegister: (content: string, linewise: boolean) => void
 getLastFind: () => { type: FindType; char: string } | null
 setLastFind: (type: FindType, char: string) => void
 recordChange: (change: RecordedChange) => void
}

/**
 * Execute an operator with a simple motion.
 */
export function executeOperatorMotion(
 op: Operator,
 motion: string,
 count: number,
 ctx: OperatorContext,
): void {
 const target = resolveMotion(motion, ctx.cursor, count)
 if (target.equals(ctx.cursor)) return

 const range = getOperatorRange(ctx.cursor, target, motion, op, count)
 applyOperator(op, range.from, range.to, ctx, range.linewise)
 ctx.recordChange({ type: 'operator', op, motion, count })
}

/**
 * Execute an operator with a find motion.
 */
export function executeOperatorFind(
 op: Operator,
 findType: FindType,
 char: string,
 count: number,
 ctx: OperatorContext,
): void {
 const targetOffset = ctx.cursor.findCharacter(char, findType, count)
 if (targetOffset === null) return

 const target = new Cursor(ctx.cursor.measuredText, targetOffset)
 const range = getOperatorRangeForFind(ctx.cursor, target, findType)

 applyOperator(op, range.from, range.to, ctx)
 ctx.setLastFind(findType, char)
 ctx.recordChange({ type: 'operatorFind', op, find: findType, char, count })
}

/**
 * Execute an operator with a text object.
 */
export function executeOperatorTextObj(
 op: Operator,
 scope: TextObjScope,
 objType: string,
 count: number,
 ctx: OperatorContext,
): void {
 const range = findTextObject(
 ctx.text,
 ctx.cursor.offset,
 objType,
 scope === 'inner',
 )
 if (!range) return

 applyOperator(op, range.start, range.end, ctx)
 ctx.recordChange({ type: 'operatorTextObj', op, objType, scope, count })
}

/**
 * Execute a line operation (dd, cc, yy).
 */
export function executeLineOp(
 op: Operator,
 count: number,
 ctx: OperatorContext,
): void {
 const text = ctx.text
 const lines = text.split('\n')
 // Calculate logical line by counting newlines before cursor offset
 // (cursor.getPosition() returns wrapped line which is wrong for this)
 const currentLine = countCharInString(text.slice(0, ctx.cursor.offset), '\n')
 const linesToAffect = Math.min(count, lines.length - currentLine)
 const lineStart = ctx.cursor.startOfLogicalLine().offset
 let lineEnd = lineStart
 for (let i = 0; i < linesToAffect; i++) {
 const nextNewline = text.indexOf('\n', lineEnd)
 lineEnd = nextNewline === -1 ? text.length : nextNewline + 1
 }

 let content = text.slice(lineStart, lineEnd)
 // Ensure linewise content ends with newline for paste detection
 if (!content.endsWith('\n')) {
 content = content + '\n'
 }
 ctx.setRegister(content, true)

 if (op === 'yank') {
 ctx.setOffset(lineStart)
 } else if (op === 'delete') {
 let deleteStart = lineStart
 const deleteEnd = lineEnd

 // If deleting to end of file and there's a preceding newline, include it
 // This ensures deleting the last line doesn't leave a trailing newline
 if (
 deleteEnd === text.length &&
 deleteStart > 0 &&
 text[deleteStart - 1] === '\n'
 ) {
 deleteStart -= 1
 }

 const newText = text.slice(0, deleteStart) + text.slice(deleteEnd)
 ctx.setText(newText || '')
 const maxOff = Math.max(
 0,
 newText.length - (lastGrapheme(newText).length || 1),
 )
 ctx.setOffset(Math.min(deleteStart, maxOff))
 } else if (op === 'change') {
 // For single line, just clear it
 if (lines.length === 1) {
 ctx.setText('')
 ctx.enterInsert(0)
 } else {
 // Delete all affected lines, replace with single empty line, enter insert
 const beforeLines = lines.slice(0, currentLine)
 const afterLines = lines.slice(currentLine + linesToAffect)
 const newText = [...beforeLines, '', ...afterLines].join('\n')
 ctx.setText(newText)
 ctx.enterInsert(lineStart)
 }
 }

 ctx.recordChange({ type: 'operator', op, motion: op[0]!, count })
}

/**
 * Execute delete character (x command).
 */
export function executeX(count: number, ctx: OperatorContext): void {
 const from = ctx.cursor.offset

 if (from >= ctx.text.length) return

 // Advance by graphemes, not code units
 let endCursor = ctx.cursor
 for (let i = 0; i < count && !endCursor.isAtEnd(); i++) {
 endCursor = endCursor.right()
 }
 const to = endCursor.offset

 const deleted = ctx.text.slice(from, to)
 const newText = ctx.text.slice(0, from) + ctx.text.slice(to)

 ctx.setRegister(deleted, false)
 ctx.setText(newText)
 const maxOff = Math.max(
 0,
 newText.length - (lastGrapheme(newText).length || 1),
 )
 ctx.setOffset(Math.min(from, maxOff))
 ctx.recordChange({ type: 'x', count })
}

/**
 * Execute replace character (r command).
 */
export function executeReplace(
 char: string,
 count: number,
 ctx: OperatorContext,
): void {
 let offset = ctx.cursor.offset
 let newText = ctx.text

 for (let i = 0; i < count && offset < newText.length; i++) {
 const graphemeLen = firstGrapheme(newText.slice(offset)).length || 1
 newText =
 newText.slice(0, offset) + char + newText.slice(offset + graphemeLen)
 offset += char.length
 }

 ctx.setText(newText)
 ctx.setOffset(Math.max(0, offset - char.length))
 ctx.recordChange({ type: 'replace', char, count })
}

/**
 * Execute toggle case (~ command).
 */
export function executeToggleCase(count: number, ctx: OperatorContext): void {
 const startOffset = ctx.cursor.offset

 if (startOffset >= ctx.text.length) return

 let newText = ctx.text
 let offset = startOffset
 let toggled = 0

 while (offset < newText.length && toggled < count) {
 const grapheme = firstGrapheme(newText.slice(offset))
 const graphemeLen = grapheme.length

 const toggledGrapheme =
 grapheme === grapheme.toUpperCase()
 ? grapheme.toLowerCase()
 : grapheme.toUpperCase()

 newText =
 newText.slice(0, offset) +
 toggledGrapheme +
 newText.slice(offset + graphemeLen)
 offset += toggledGrapheme.length
 toggled++
 }

 ctx.setText(newText)
 // Cursor moves to position after the last toggled character
 // At end of line, cursor can be at the "end" position
 ctx.setOffset(offset)
 ctx.recordChange({ type: 'toggleCase', count })
}

/**
 * Execute join lines (J command).
 */
export function executeJoin(count: number, ctx: OperatorContext): void {
 const text = ctx.text
 const lines = text.split('\n')
 const { line: currentLine } = ctx.cursor.getPosition()

 if (currentLine >= lines.length - 1) return

 const linesToJoin = Math.min(count, lines.length - currentLine - 1)
 let joinedLine = lines[currentLine]!
 const cursorPos = joinedLine.length

 for (let i = 1; i <= linesToJoin; i++) {
 const nextLine = (lines[currentLine + i] ?? '').trimStart()
 if (nextLine.length > 0) {
 if (!joinedLine.endsWith('') && joinedLine.length > 0) {
 joinedLine += ''
 }
 joinedLine += nextLine
 }
 }

 const newLines = [
 ...lines.slice(0, currentLine),
 joinedLine,
 ...lines.slice(currentLine + linesToJoin + 1),
 ]

 const newText = newLines.join('\n')
 ctx.setText(newText)
 ctx.setOffset(getLineStartOffset(newLines, currentLine) + cursorPos)
 ctx.recordChange({ type: 'join', count })
}

/**
 * Execute paste (p/P command).
 */
export function executePaste(
 after: boolean,
 count: number,
 ctx: OperatorContext,
): void {
 const register = ctx.getRegister()
 if (!register) return

 const isLinewise = register.endsWith('\n')
 const content = isLinewise ? register.slice(0, -1) : register

 if (isLinewise) {
 const text = ctx.text
 const lines = text.split('\n')
 const { line: currentLine } = ctx.cursor.getPosition()

 const insertLine = after ? currentLine + 1 : currentLine
 const contentLines = content.split('\n')
 const repeatedLines: string[] = []
 for (let i = 0; i < count; i++) {
 repeatedLines.push(...contentLines)
 }

 const newLines = [
 ...lines.slice(0, insertLine),
 ...repeatedLines,
 ...lines.slice(insertLine),
 ]

 const newText = newLines.join('\n')
 ctx.setText(newText)
 ctx.setOffset(getLineStartOffset(newLines, insertLine))
 } else {
 const textToInsert = content.repeat(count)
 const insertPoint =
 after && ctx.cursor.offset < ctx.text.length
 ? ctx.cursor.measuredText.nextOffset(ctx.cursor.offset)
 : ctx.cursor.offset

 const newText =
 ctx.text.slice(0, insertPoint) +
 textToInsert +
 ctx.text.slice(insertPoint)
 const lastGr = lastGrapheme(textToInsert)
 const newOffset = insertPoint + textToInsert.length - (lastGr.length || 1)

 ctx.setText(newText)
 ctx.setOffset(Math.max(insertPoint, newOffset))
 }
}

/**
 * Execute indent (>> command).
 */
export function executeIndent(
 dir: '>' | '<',
 count: number,
 ctx: OperatorContext,
): void {
 const text = ctx.text
 const lines = text.split('\n')
 const { line: currentLine } = ctx.cursor.getPosition()
 const linesToAffect = Math.min(count, lines.length - currentLine)
 const indent = '' // Two spaces

 for (let i = 0; i < linesToAffect; i++) {
 const lineIdx = currentLine + i
 const line = lines[lineIdx] ?? ''

 if (dir === '>') {
 lines[lineIdx] = indent + line
 } else if (line.startsWith(indent)) {
 lines[lineIdx] = line.slice(indent.length)
 } else if (line.startsWith('\t')) {
 lines[lineIdx] = line.slice(1)
 } else {
 // Remove as much leading whitespace as possible up to indent length
 let removed = 0
 let idx = 0
 while (
 idx < line.length &&
 removed < indent.length &&
 /\s/.test(line[idx]!)
 ) {
 removed++
 idx++
 }
 lines[lineIdx] = line.slice(idx)
 }
 }

 const newText = lines.join('\n')
 const currentLineText = lines[currentLine] ?? ''
 const firstNonBlank = (currentLineText.match(/^\s*/)?.[0] ?? '').length

 ctx.setText(newText)
 ctx.setOffset(getLineStartOffset(lines, currentLine) + firstNonBlank)
 ctx.recordChange({ type: 'indent', dir, count })
}

/**
 * Execute open line (o/O command).
 */
export function executeOpenLine(
 direction: 'above' | 'below',
 ctx: OperatorContext,
): void {
 const text = ctx.text
 const lines = text.split('\n')
 const { line: currentLine } = ctx.cursor.getPosition()

 const insertLine = direction === 'below' ? currentLine + 1 : currentLine
 const newLines = [
 ...lines.slice(0, insertLine),
 '',
 ...lines.slice(insertLine),
 ]

 const newText = newLines.join('\n')
 ctx.setText(newText)
 ctx.enterInsert(getLineStartOffset(newLines, insertLine))
 ctx.recordChange({ type: 'openLine', direction })
}

// ============================================================================
// Internal Helpers
// ============================================================================

/**
 * Calculate the offset of a line's start position.
 */
function getLineStartOffset(lines: string[], lineIndex: number): number {
 return lines.slice(0, lineIndex).join('\n').length + (lineIndex > 0 ? 1 : 0)
}

function getOperatorRange(
 cursor: Cursor,
 target: Cursor,
 motion: string,
 op: Operator,
 count: number,
): { from: number; to: number; linewise: boolean } {
 let from = Math.min(cursor.offset, target.offset)
 let to = Math.max(cursor.offset, target.offset)
 let linewise = false

 // Special case: cw/cW changes to end of word, not start of next word
 if (op === 'change' && (motion === 'w' || motion === 'W')) {
 // For cw with count, move forward (count-1) words, then find end of that word
 let wordCursor = cursor
 for (let i = 0; i < count - 1; i++) {
 wordCursor =
 motion === 'w' ? wordCursor.nextVimWord() : wordCursor.nextWORD()
 }
 const wordEnd =
 motion === 'w' ? wordCursor.endOfVimWord() : wordCursor.endOfWORD()
 to = cursor.measuredText.nextOffset(wordEnd.offset)
 } else if (isLinewiseMotion(motion)) {
 // Linewise motions extend to include entire lines
 linewise = true
 const text = cursor.text
 const nextNewline = text.indexOf('\n', to)
 if (nextNewline === -1) {
 // Deleting to end of file - include the preceding newline if exists
 to = text.length
 if (from > 0 && text[from - 1] === '\n') {
 from -= 1
 }
 } else {
 to = nextNewline + 1
 }
 } else if (isInclusiveMotion(motion) && cursor.offset <= target.offset) {
 to = cursor.measuredText.nextOffset(to)
 }

 // Word motions can land inside an [Image #N] chip; extend the range to
 // cover the whole chip so dw/cw/yw never leave a partial placeholder.
 from = cursor.snapOutOfImageRef(from, 'start')
 to = cursor.snapOutOfImageRef(to, 'end')

 return { from, to, linewise }
}

/**
 * Get the range for a find-based operator.
 * Note: _findType is unused because Cursor.findCharacter already adjusts
 * the offset for t/T motions. All find types are treated as inclusive here.
 */
function getOperatorRangeForFind(
 cursor: Cursor,
 target: Cursor,
 _findType: FindType,
): { from: number; to: number } {
 const from = Math.min(cursor.offset, target.offset)
 const maxOffset = Math.max(cursor.offset, target.offset)
 const to = cursor.measuredText.nextOffset(maxOffset)
 return { from, to }
}

function applyOperator(
 op: Operator,
 from: number,
 to: number,
 ctx: OperatorContext,
 linewise: boolean = false,
): void {
 let content = ctx.text.slice(from, to)
 // Ensure linewise content ends with newline for paste detection
 if (linewise && !content.endsWith('\n')) {
 content = content + '\n'
 }
 ctx.setRegister(content, linewise)

 if (op === 'yank') {
 ctx.setOffset(from)
 } else if (op === 'delete') {
 const newText = ctx.text.slice(0, from) + ctx.text.slice(to)
 ctx.setText(newText)
 const maxOff = Math.max(
 0,
 newText.length - (lastGrapheme(newText).length || 1),
 )
 ctx.setOffset(Math.min(from, maxOff))
 } else if (op === 'change') {
 const newText = ctx.text.slice(0, from) + ctx.text.slice(to)
 ctx.setText(newText)
 ctx.enterInsert(from)
 }
}

export function executeOperatorG(
 op: Operator,
 count: number,
 ctx: OperatorContext,
): void {
 // count=1 means no count given, target = end of file
 // otherwise target = line N
 const target =
 count === 1 ? ctx.cursor.startOfLastLine() : ctx.cursor.goToLine(count)

 if (target.equals(ctx.cursor)) return

 const range = getOperatorRange(ctx.cursor, target, 'G', op, count)
 applyOperator(op, range.from, range.to, ctx, range.linewise)
 ctx.recordChange({ type: 'operator', op, motion: 'G', count })
}

export function executeOperatorGg(
 op: Operator,
 count: number,
 ctx: OperatorContext,
): void {
 // count=1 means no count given, target = first line
 // otherwise target = line N
 const target =
 count === 1 ? ctx.cursor.startOfFirstLine() : ctx.cursor.goToLine(count)

 if (target.equals(ctx.cursor)) return

 const range = getOperatorRange(ctx.cursor, target, 'gg', op, count)
 applyOperator(op, range.from, range.to, ctx, range.linewise)
 ctx.recordChange({ type: 'operator', op, motion: 'gg', count })
}