// ✅ ENFORCED: Strict mode with comprehensive type checking
// ✅ ENFORCED: No implicit any types
// ✅ ENFORCED: No unused variables or parameters
// ✅ ENFORCED: All code paths must return
// ✅ ENFORCED: Explicit type annotations required
// ✅ ENFORCED: No unreachable code
// ✅ ENFORCED: Exact optional property types
// ✅ ENFORCED: No unchecked indexed access

// ❌ This will fail:
function badFunction(input) {  // implicit any
  if (condition) return value  // not all paths return
  const unused = "never used"  // unused variable
}

// ✅ This passes:
function goodFunction: (input: string) => string = (input: string): string => {
  if (condition) {
    return value
  }
  return defaultValue
}

// ✅ ENFORCED: Single quotes, no semicolons
// ✅ ENFORCED: 2-space indentation
// ✅ ENFORCED: No trailing commas
// ✅ ENFORCED: Required curly braces
// ✅ ENFORCED: Spaces inside object braces
// ✅ ENFORCED: No spaces inside array brackets
// ✅ ENFORCED: Consistent naming conventions

// ❌ This will fail:
const obj = {a: 1, b: 2,};   // trailing comma
const arr = [ 1, 2, 3 ];     // spaces in array
if(condition) return value;  // no curly braces, semicolon

// ✅ This passes:
const obj = { a: 1, b: 2 }
const arr = [1, 2, 3]
if (condition) {
  return value
}

// ✅ ENFORCED: Prefer const over let/var
// ✅ ENFORCED: Arrow functions for callbacks
// ✅ ENFORCED: Template literals over concatenation
// ✅ ENFORCED: Object destructuring where applicable
// ✅ ENFORCED: No inline comments
// ✅ ENFORCED: Cognitive complexity ≤ 15
// ✅ ENFORCED: No duplicate code
// ✅ ENFORCED: Prefer immediate returns

// ❌ This will fail:
var oldWay = "string" + variable;  // var, concatenation
function callback() { return value; }  // function instead of arrow
// inline comment  // inline comment

// ✅ This passes:
const newWay = `string ${variable}`
const callback = () => value
// Block comment for complex logic

// ✅ ENFORCED: No duplicate strings
// ✅ ENFORCED: No identical functions
// ✅ ENFORCED: No redundant boolean expressions
// ✅ ENFORCED: Prefer immediate returns
// ✅ ENFORCED: No one-iteration loops
// ✅ ENFORCED: No unused variables
// ✅ ENFORCED: No unreachable code

// ❌ This will fail:
const message = "Hello"
const greeting = "Hello"   // duplicate string

if (condition === true) {  // redundant boolean
  return value
}

// ✅ This passes:
const MESSAGES = {
  GREETING: "Hello"
} as const

if (condition) {
  return value
}

// Configuration options interface
export interface ConfigOptions {
  readonly debug: boolean
  readonly timeout: number
  readonly retries: number
}

// Result type for operations (success/error handling)
export type Result<T> = {
  readonly success: boolean
  readonly data?: T
  readonly error?: string
}

// Event handler type
export type EventHandler<T = unknown> = (event: T) => void

// Async operation type
export type AsyncOperation<T> = () => Promise<T>

// Validation function type
export type Validator<T> = (value: T) => boolean

// String validation
export const isNotEmpty: (value: string) => boolean

// Result constructors
export const createSuccessResult: <T>(data: T) => Result<T>
export const createErrorResult: <T>(error: string) => Result<T>

// Async utilities
export const delay: (ms: number) => Promise<void>

// Example function (demonstrates strict typing)
export const exampleFunction: (input: string) => string

// Example class (demonstrates OOP with strict rules)
export class ExampleClass {
  constructor(value: string)
  public getValue(): string
  public setValue(newValue: string): void
}

import {
  exampleFunction,
  ExampleClass,
  isNotEmpty,
  createSuccessResult,
  createErrorResult,
  delay,
  type ConfigOptions,
  type Result
} from 'typescript-starter'

// Function usage
const result = exampleFunction('hello world')
console.log(result) // "HELLO WORLD"

// Class usage
const instance = new ExampleClass('test value')
console.log(instance.getValue()) // "TEST VALUE"

// Utility usage
console.log(isNotEmpty('valid')) // true
console.log(isNotEmpty('')) // false

const success = createSuccessResult({ message: 'OK' })
const error = createErrorResult<string>('Failed')

// Async usage
await delay(1000)
console.log('Delayed execution')

// ❌ Too complex (will fail)
function complexFunction(input: string): string {
  if (condition1) {
    if (condition2) {
      if (condition3) {
        if (condition4) {
          if (condition5) {
            return "too complex"
          }
        }
      }
    }
  }
  return "default"
}

// ✅ Simple and clear (passes)
function simpleFunction(input: string): string {
  if (!condition1) return "default"
  if (!condition2) return "default"
  if (!condition3) return "default"
  return "result"
}

// ❌ These will fail compilation
function badFunction(input) {           // implicit any
  if (condition) return value           // not all paths return
  const unused = "never used"           // unused variable
}

// ✅ These pass strict checking
function goodFunction(input: string): string {
  if (condition) {
    return value
  }
  return defaultValue
}

// tests/example.test.ts
import { exampleFunction, ExampleClass } from '@/index'

describe('exampleFunction', () => {
  it('should convert string to uppercase', () => {
    const result = exampleFunction('test')
    expect(result).toBe('TEST')
  })
})

describe('ExampleClass', () => {
  let instance: ExampleClass

  beforeEach(() => {
    instance = new ExampleClass('initial')
  })

  it('should set and get values correctly', () => {
    instance.setValue('new value')
    expect(instance.getValue()).toBe('NEW VALUE')
  })
})

/**
 * Example function demonstrating strict rules
 * @param input - Input string to process
 * @returns Processed string in uppercase
 */
export const exampleFunction: (input: string) => string = (input: string): string => {
  return input.toUpperCase()
}

/**
 * Example class with strict typing
 */
export class ExampleClass {
  private value: string

  constructor(initialValue: string) {
    this.value = initialValue.toUpperCase()
  }

  /**
   * Get the current value
   * @returns The current value in uppercase
   */
  public getValue(): string {
    return this.value
  }

  /**
   * Set a new value
   * @param newValue - The new value to set
   */
  public setValue(newValue: string): void {
    this.value = newValue.toUpperCase()
  }
}

// ❌ Relative imports (messy)
import { utils } from '../../../utils/helper'

// ✅ Path aliases (clean)
import { utils } from '@/utils/helper'
import { types } from '@types/common'
import { helpers } from '@utils/helpers'