import type {
  DayTimeData,
  MonthTimeData,
  YearTimeData,
  TimingSession,
  TabRecord,
  TabType,
  TimeTrackingEvent,
} from '../../../shared/types.js'
import { getTabTypeFromPath, getFileNameFromPath } from '../../../shared/utils/tabType.js'
import { logger } from '../../utils/logger.js'
import { HeartbeatService, createHeartbeatService } from './heartbeatService.js'
import { SessionPersistence, createSessionPersistence } from './sessionPersistence.js'

const generateId = (): string => {
  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
}

export interface TimeTrackerServiceDependencies {
  heartbeatService: HeartbeatService
  persistence: SessionPersistence
}

export interface TimeTrackerServiceConfig {
  heartbeatIntervalMs?: number
}

class TimeTrackerService {
  private currentSession: TimingSession | null = null
  private currentTabRecord: TabRecord | null = null
  private isPaused: boolean = false
  private todayDuration: number = 0
  private _initialized: boolean = false
  private static _initializationPromise: Promise<void> | null = null

  private readonly heartbeatService: HeartbeatService
  private readonly persistence: SessionPersistence

  private constructor(
    dependencies: TimeTrackerServiceDependencies
  ) {
    this.heartbeatService = dependencies.heartbeatService
    this.persistence = dependencies.persistence
  }

  static async create(
    config?: TimeTrackerServiceConfig
  ): Promise<TimeTrackerService> {
    const heartbeatService = createHeartbeatService(config?.heartbeatIntervalMs)
    const persistence = createSessionPersistence()

    const instance = new TimeTrackerService({
      heartbeatService,
      persistence
    })

    await instance.initialize()
    return instance
  }

  static async createWithDependencies(
    dependencies: TimeTrackerServiceDependencies
  ): Promise<TimeTrackerService> {
    const instance = new TimeTrackerService(dependencies)
    await instance.initialize()
    return instance
  }

  private async initialize(): Promise<void> {
    if (this._initialized) {
      return
    }

    if (TimeTrackerService._initializationPromise) {
      await TimeTrackerService._initializationPromise
      return
    }

    TimeTrackerService._initializationPromise = this.loadCurrentState()
    await TimeTrackerService._initializationPromise
    this._initialized = true
    TimeTrackerService._initializationPromise = null

    this.heartbeatService.setCallback(async () => {
      if (this.currentSession && !this.isPaused) {
        try {
          this.heartbeatService.updateHeartbeat()
          await this.updateCurrentTabDuration()
          await this.saveCurrentState()
          await this.updateTodayDataRealtime()
        } catch (err) {
          logger.error('Heartbeat update failed:', err)
        }
      }
    })
  }

  ensureInitialized(): void {
    if (!this._initialized) {
      throw new Error('TimeTrackerService 未初始化，请使用 TimeTrackerService.create() 创建实例')
    }
  }

  private async loadCurrentState(): Promise<void> {
    const now = new Date()
    const todayData = await this.persistence.getDayData(now.getFullYear(), now.getMonth() + 1, now.getDate())
    this.todayDuration = todayData.totalDuration

    const state = await this.persistence.loadCurrentState()
    if (state.session && state.session.status === 'active') {
      const sessionStart = new Date(state.session.startTime)
      const now = new Date()
      if (now.getTime() - sessionStart.getTime() < 24 * 60 * 60 * 1000) {
        this.currentSession = state.session
        this.isPaused = state.isPaused
        if (state.currentTabRecord) {
          this.currentTabRecord = state.currentTabRecord
        }
        this.heartbeatService.restoreState({ lastHeartbeat: state.lastHeartbeat })
      } else {
        await this.endSession()
      }
    }
  }

  private async saveCurrentState(): Promise<void> {
    await this.persistence.saveCurrentState({
      session: this.currentSession,
      currentTabRecord: this.currentTabRecord,
      isPaused: this.isPaused,
      lastHeartbeat: this.heartbeatService.getLastHeartbeat().toISOString()
    })
  }

  async startSession(): Promise<TimingSession> {
    if (this.currentSession && this.currentSession.status === 'active') {
      return this.currentSession
    }

    const now = new Date()
    this.currentSession = {
      id: generateId(),
      startTime: now.toISOString(),
      duration: 0,
      status: 'active',
      tabRecords: []
    }
    this.isPaused = false
    this.heartbeatService.updateHeartbeat()

    this.heartbeatService.start()
    await this.saveCurrentState()

    return this.currentSession
  }

  async pauseSession(): Promise<void> {
    if (!this.currentSession || this.isPaused) return

    this.isPaused = true
    await this.updateCurrentTabDuration()
    await this.saveCurrentState()
  }

  async resumeSession(): Promise<void> {
    if (!this.currentSession || !this.isPaused) return

    this.isPaused = false
    this.heartbeatService.updateHeartbeat()

    if (this.currentTabRecord) {
      const now = new Date()
      const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`
      this.currentTabRecord.focusedPeriods.push({ start: timeStr, end: timeStr })
    }

    await this.saveCurrentState()
  }

  async endSession(): Promise<void> {
    if (!this.currentSession) return

    this.heartbeatService.stop()

    await this.updateCurrentTabDuration()

    const now = new Date()
    this.currentSession.endTime = now.toISOString()
    this.currentSession.status = 'ended'

    const startTime = new Date(this.currentSession.startTime)
    this.currentSession.duration = Math.floor((now.getTime() - startTime.getTime()) / 1000)

    await this.persistence.saveSessionToDay(this.currentSession)

    this.todayDuration += this.currentSession.duration

    this.currentSession = null
    this.currentTabRecord = null
    this.isPaused = false

    await this.persistence.clearCurrentState()
  }

  private async updateCurrentTabDuration(): Promise<void> {
    if (!this.currentSession || !this.currentTabRecord) return

    const now = new Date()
    const periods = this.currentTabRecord.focusedPeriods

    if (periods.length > 0) {
      const lastPeriod = periods[periods.length - 1]
      const [h, m, s] = lastPeriod.start.split(':').map(Number)
      const startSeconds = h * 3600 + m * 60 + s
      const currentSeconds = now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds()

      this.currentTabRecord.duration = currentSeconds - startSeconds
      lastPeriod.end = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`
    }
  }

  private async updateTodayDataRealtime(): Promise<void> {
    if (!this.currentSession) return

    const now = new Date()
    const year = now.getFullYear()
    const month = now.getMonth() + 1
    const day = now.getDate()

    const dayData = await this.persistence.updateDayDataRealtime(
      year,
      month,
      day,
      this.currentSession,
      this.currentTabRecord
    )

    this.todayDuration = dayData.totalDuration

    await this.persistence.recalculateMonthSummary(year, month, this.todayDuration)
    await this.persistence.recalculateYearSummary(year)
  }

  async handleTabSwitch(tabInfo: { tabId: string; filePath: string | null }): Promise<void> {
    if (!this.currentSession || this.isPaused) return

    await this.updateCurrentTabDuration()

    if (this.currentTabRecord && this.currentTabRecord.duration > 0) {
      this.currentSession.tabRecords.push({ ...this.currentTabRecord })
    }

    const now = new Date()
    const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`

    this.currentTabRecord = {
      tabId: tabInfo.tabId,
      filePath: tabInfo.filePath,
      fileName: getFileNameFromPath(tabInfo.filePath),
      tabType: getTabTypeFromPath(tabInfo.filePath),
      duration: 0,
      focusedPeriods: [{ start: timeStr, end: timeStr }]
    }

    await this.saveCurrentState()
  }

  async handleEvent(event: TimeTrackingEvent): Promise<void> {
    switch (event.type) {
      case 'window-focus':
        if (!this.currentSession) {
          await this.startSession()
          if (event.tabInfo) {
            await this.handleTabSwitch(event.tabInfo)
          }
        } else {
          await this.resumeSession()
          await this.updateTodayDataRealtime()
        }
        break
      case 'window-blur':
        await this.pauseSession()
        await this.updateTodayDataRealtime()
        break
      case 'app-quit':
        await this.endSession()
        break
      case 'tab-switch':
      case 'tab-open':
        if (!this.currentSession) {
          await this.startSession()
        }
        if (event.tabInfo) {
          await this.handleTabSwitch(event.tabInfo)
        }
        await this.updateTodayDataRealtime()
        break
      case 'tab-close':
        await this.updateCurrentTabDuration()
        await this.updateTodayDataRealtime()
        break
      case 'heartbeat':
        if (this.currentSession && !this.isPaused) {
          this.heartbeatService.updateHeartbeat()
          await this.updateCurrentTabDuration()
          await this.saveCurrentState()
          await this.updateTodayDataRealtime()
        }
        break
    }
  }

  async getDayData(year: number, month: number, day: number): Promise<DayTimeData> {
    return this.persistence.getDayData(year, month, day)
  }

  async getWeekData(startDate: Date): Promise<DayTimeData[]> {
    const result: DayTimeData[] = []
    for (let i = 0; i < 7; i++) {
      const date = new Date(startDate)
      date.setDate(date.getDate() + i)
      const data = await this.persistence.getDayData(date.getFullYear(), date.getMonth() + 1, date.getDate())
      result.push(data)
    }
    return result
  }

  async getMonthData(year: number, month: number): Promise<MonthTimeData> {
    return this.persistence.getMonthData(year, month)
  }

  async getYearData(year: number): Promise<YearTimeData> {
    return this.persistence.getYearData(year)
  }

  getCurrentState(): { isRunning: boolean; isPaused: boolean; currentSession: TimingSession | null; todayDuration: number; currentTabRecord: TabRecord | null } {
    return {
      isRunning: this.currentSession !== null,
      isPaused: this.isPaused,
      currentSession: this.currentSession,
      todayDuration: this.todayDuration,
      currentTabRecord: this.currentTabRecord
    }
  }

  async getStats(year?: number, month?: number): Promise<{
    totalDuration: number
    activeDays: number
    averageDaily: number
    longestDay: { date: string; duration: number } | null
    longestSession: { date: string; duration: number } | null
    topTabs: Array<{ fileName: string; duration: number; percentage: number }>
    tabTypeDistribution: Array<{ tabType: TabType; duration: number; percentage: number }>
  }> {
    const now = new Date()
    const targetYear = year || now.getFullYear()
    const targetMonth = month

    let totalDuration = 0
    let activeDays = 0
    let longestDay: { date: string; duration: number } | null = null
    let longestSession: { date: string; duration: number } | null = null
    const tabDurations: Record<string, number> = {}
    const tabTypeDurations: Record<TabType, number> = {} as Record<TabType, number>

    if (targetMonth) {
      const monthData = await this.persistence.getMonthData(targetYear, targetMonth)
      totalDuration = monthData.monthlyTotal
      activeDays = Object.values(monthData.days).filter(d => d.totalDuration > 0).length

      for (const [day, summary] of Object.entries(monthData.days)) {
        if (!longestDay || summary.totalDuration > longestDay.duration) {
          longestDay = { date: `${targetYear}-${targetMonth.toString().padStart(2, '0')}-${day}`, duration: summary.totalDuration }
        }
        for (const tab of summary.topTabs || []) {
          tabDurations[tab.fileName] = (tabDurations[tab.fileName] || 0) + tab.duration
        }
      }

      const dayData = await this.persistence.getDayData(targetYear, targetMonth, 1)
      for (const session of dayData.sessions) {
        for (const record of session.tabRecords) {
          const key = record.filePath || record.fileName
          tabDurations[key] = (tabDurations[key] || 0) + record.duration
          tabTypeDurations[record.tabType] = (tabTypeDurations[record.tabType] || 0) + record.duration
        }
      }
    } else {
      const yearData = await this.persistence.getYearData(targetYear)
      totalDuration = yearData.yearlyTotal
      activeDays = Object.values(yearData.months).reduce((sum, m) => {
        return sum + Object.entries(m).filter(([_, d]) => (d as { totalDuration: number }).totalDuration > 0).length
      }, 0)

      for (const [month, summary] of Object.entries(yearData.months)) {
        if (!longestDay || summary.totalDuration > longestDay.duration) {
          longestDay = { date: `${targetYear}-${month}`, duration: summary.totalDuration }
        }
      }

      for (let m = 1; m <= 12; m++) {
        const monthStr = m.toString().padStart(2, '0')
        const monthData = await this.persistence.getMonthData(targetYear, m)
        for (const dayData of Object.values(monthData.days)) {
          for (const tab of dayData.topTabs || []) {
            tabDurations[tab.fileName] = (tabDurations[tab.fileName] || 0) + tab.duration
          }
        }
      }
    }

    return {
      totalDuration,
      activeDays,
      averageDaily: activeDays > 0 ? Math.floor(totalDuration / activeDays) : 0,
      longestDay,
      longestSession,
      topTabs: Object.entries(tabDurations)
        .map(([fileName, duration]) => ({
          fileName,
          duration,
          percentage: totalDuration > 0 ? Math.round((duration / totalDuration) * 100) : 0
        }))
        .sort((a, b) => b.duration - a.duration)
        .slice(0, 10),
      tabTypeDistribution: Object.entries(tabTypeDurations)
        .map(([tabType, duration]) => ({
          tabType: tabType as TabType,
          duration,
          percentage: totalDuration > 0 ? Math.round((duration / totalDuration) * 100) : 0
        }))
        .sort((a, b) => b.duration - a.duration)
    }
  }
}

let _timeTrackerService: TimeTrackerService | null = null

export const getTimeTrackerService = (): TimeTrackerService => {
  if (!_timeTrackerService) {
    throw new Error('TimeTrackerService 未初始化，请先调用 initializeTimeTrackerService()')
  }
  return _timeTrackerService
}

export const initializeTimeTrackerService = async (
  config?: TimeTrackerServiceConfig
): Promise<TimeTrackerService> => {
  if (_timeTrackerService) {
    return _timeTrackerService
  }
  _timeTrackerService = await TimeTrackerService.create(config)
  return _timeTrackerService
}

export const initializeTimeTrackerServiceWithDependencies = async (
  dependencies: TimeTrackerServiceDependencies
): Promise<TimeTrackerService> => {
  if (_timeTrackerService) {
    return _timeTrackerService
  }
  _timeTrackerService = await TimeTrackerService.createWithDependencies(dependencies)
  return _timeTrackerService
}

export { TimeTrackerService }