import type { Display } from "electron"
import type { ExifData } from "exif"
import type { Stats } from "fs"
import type { Bible } from "json-bible/lib/Bible"
import type { SyncProviderId } from "../../electron/cloud/syncManager"
import type { ContentFile, ContentLibraryCategory, ContentProviderId, MediaLicense } from "../../electron/contentProviders/base/types"
import type { PCOFolderTreeNode } from "../../electron/contentProviders/planningCenter/request"
import type { _store } from "../../electron/data/store"
import type { TimecodeMode } from "../../electron/timecode/timecode"
import type { ErrorLog, FileFolder, LessonsData, LyricSearchResult, MainFilePaths, Media, OS, SpotifyState, Subtitle } from "../Main"
import type { Output } from "../Output"
import type { Folders, Projects } from "../Projects"
import type { Dictionary, Resolution, Themes } from "../Settings"
import type { Overlays, Show, Shows, Templates, TrimmedShows } from "../Show"
import type { ServerData } from "../Socket"
import type { StageLayouts } from "../Stage"
import type { Event } from "./../Calendar"
import type { History } from "./../History"
import type { SaveData, SaveListSyncedSettings } from "./../Save"

export const MAIN = "MAIN"

export enum Main {
    // DEV
    LOG = "LOG",
    IS_DEV = "IS_DEV",
    GET_CACHE_PATH = "GET_CACHE_PATH",
    // APP
    VERSION = "VERSION",
    GET_OS = "GET_OS",
    DEVICE_ID = "DEVICE_ID",
    GET_DEVICE_NAME = "GET_DEVICE_NAME",
    IP = "IP",
    CHECK_RAM_USAGE = "CHECK_RAM_USAGE",
    // STORES
    SETTINGS = "SETTINGS",
    SYNCED_SETTINGS = "SYNCED_SETTINGS",
    STAGE = "STAGE",
    PROJECTS = "PROJECTS",
    OVERLAYS = "OVERLAYS",
    TEMPLATES = "TEMPLATES",
    EVENTS = "EVENTS",
    MEDIA = "MEDIA",
    THEMES = "THEMES",
    DRIVE_API_KEY = "DRIVE_API_KEY",
    HISTORY = "HISTORY",
    USAGE = "USAGE",
    CACHE = "CACHE",
    // WINDOW
    CLOSE = "CLOSE",
    MAXIMIZE = "MAXIMIZE",
    MAXIMIZED = "MAXIMIZED",
    MINIMIZE = "MINIMIZE",
    FULLSCREEN = "FULLSCREEN",
    /////
    IMPORT = "IMPORT",
    IMPORT_FILES = "IMPORT_FILES",
    BIBLE = "BIBLE",
    SHOW = "SHOW",
    SAVE = "SAVE",
    BACKUPS = "BACKUPS",
    DELETE_BACKUP = "DELETE_BACKUP",
    ///////////////////
    SPELLCHECK = "SPELLCHECK",
    ////
    SHOWS = "SHOWS",
    AUTO_UPDATE = "AUTO_UPDATE",
    URL = "URL",
    LANGUAGE = "LANGUAGE",
    GET_PATHS = "GET_PATHS",
    DATA_PATH = "DATA_PATH",
    UPDATE_DATA_PATH = "UPDATE_DATA_PATH",
    LOG_ERROR = "LOG_ERROR",
    OPEN_LOG = "OPEN_LOG",
    OPEN_CACHE = "OPEN_CACHE",
    OPEN_APPDATA = "OPEN_APPDATA",
    OPEN_FOLDER_PATH = "OPEN_FOLDER_PATH",
    OPEN_NOW_PLAYING = "OPEN_NOW_PLAYING",
    GET_STORE_VALUE = "GET_STORE_VALUE",
    SET_STORE_VALUE = "SET_STORE_VALUE",
    DELETE_SHOWS = "DELETE_SHOWS",
    DELETE_SHOWS_NI = "DELETE_SHOWS_NI",
    REFRESH_SHOWS = "REFRESH_SHOWS",
    GET_EMPTY_SHOWS = "GET_EMPTY_SHOWS",
    FULL_SHOWS_LIST = "FULL_SHOWS_LIST",
    GET_SCREENS = "GET_SCREENS",
    GET_WINDOWS = "GET_WINDOWS",
    GET_DISPLAYS = "GET_DISPLAYS",
    OUTPUT = "OUTPUT",
    DOES_MEDIA_EXIST = "DOES_MEDIA_EXIST",
    GET_THUMBNAIL = "GET_THUMBNAIL",
    SAVE_IMAGE = "SAVE_IMAGE",
    PDF_TO_IMAGE = "PDF_TO_IMAGE",
    READ_EXIF = "READ_EXIF",
    MEDIA_CODEC = "MEDIA_CODEC",
    MEDIA_TRACKS = "MEDIA_TRACKS",
    DOWNLOAD_LESSONS_MEDIA = "DOWNLOAD_LESSONS_MEDIA",
    MEDIA_DOWNLOAD = "MEDIA_DOWNLOAD",
    MEDIA_IS_DOWNLOADED = "MEDIA_IS_DOWNLOADED",
    NOW_PLAYING = "NOW_PLAYING",
    NOW_PLAYING_UNSET = "NOW_PLAYING_UNSET",
    // MEDIA_BASE64 = "MEDIA_BASE64",
    READ_AUDIO_METADATA = "READ_AUDIO_METADATA",
    CAPTURE_SLIDE = "CAPTURE_SLIDE",
    ACCESS_CAMERA_PERMISSION = "ACCESS_CAMERA_PERMISSION",
    ACCESS_MICROPHONE_PERMISSION = "ACCESS_MICROPHONE_PERMISSION",
    ACCESS_SCREEN_PERMISSION = "ACCESS_SCREEN_PERMISSION",
    LIBREOFFICE_CONVERT = "LIBREOFFICE_CONVERT",
    SLIDESHOW_GET_APPS = "SLIDESHOW_GET_APPS",
    START_SLIDESHOW = "START_SLIDESHOW",
    PRESENTATION_CONTROL = "PRESENTATION_CONTROL",
    START = "START",
    STOP = "STOP",
    SERVER_DATA = "SERVER_DATA",
    WEBSOCKET_START = "WEBSOCKET_START",
    WEBSOCKET_STOP = "WEBSOCKET_STOP",
    API_TRIGGER = "API_TRIGGER",
    EMIT_OSC = "EMIT_OSC",
    GET_MIDI_OUTPUTS = "GET_MIDI_OUTPUTS",
    GET_MIDI_INPUTS = "GET_MIDI_INPUTS",
    SEND_MIDI = "SEND_MIDI",
    RECEIVE_MIDI = "RECEIVE_MIDI",
    CLOSE_MIDI = "CLOSE_MIDI",
    GET_LYRICS = "GET_LYRICS",
    SEARCH_LYRICS = "SEARCH_LYRICS",
    RECORDER = "RECORDER",
    RESTORE = "RESTORE",
    SYSTEM_OPEN = "SYSTEM_OPEN",
    LOCATE_MEDIA_FILE = "LOCATE_MEDIA_FILE",
    GET_MEDIA_FOLDER_PATH = "GET_MEDIA_FOLDER_PATH",
    SET_MEDIA_FOLDER_PATH = "SET_MEDIA_FOLDER_PATH",
    GET_SIMILAR = "GET_SIMILAR",
    BUNDLE_MEDIA_FILES = "BUNDLE_MEDIA_FILES",
    MEDIA_FOLDER_COPY = "MEDIA_FOLDER_COPY",
    READ_BIBLES_FOLDER = "READ_BIBLES_FOLDER",
    FILE_INFO = "FILE_INFO",
    READ_FOLDER = "READ_FOLDER",
    READ_FILE = "READ_FILE",
    OPEN_FOLDER = "OPEN_FOLDER",
    OPEN_FILE = "OPEN_FILE",
    // SYNC
    CAN_SYNC = "CAN_SYNC",
    GET_TEAMS = "GET_TEAMS",
    CLOUD_DATA = "CLOUD_DATA",
    CLOUD_CHANGED = "CLOUD_CHANGED",
    CLOUD_SYNC = "CLOUD_SYNC",
    RESTORE_CLOUD_BACKUP = "RESTORE_CLOUD_BACKUP",
    GET_CONVERSATION_ID = "GET_CONVERSATION_ID",
    SEND_SOCKET_MESSAGE = "SEND_SOCKET_MESSAGE",
    // Provider-based routing
    PROVIDER_LOAD_SERVICES = "PROVIDER_LOAD_SERVICES",
    PROVIDER_DISCONNECT = "PROVIDER_DISCONNECT",
    PROVIDER_STARTUP_LOAD = "PROVIDER_STARTUP_LOAD",
    PROVIDER_FETCH_FOLDERS = "PROVIDER_FETCH_FOLDERS",
    PCO_LIVE_GET = "PCO_LIVE_GET",
    PCO_PUSHER_AUTH = "PCO_PUSHER_AUTH",
    PCO_FETCH_SERVICE_TREE = "PCO_FETCH_SERVICE_TREE",
    PCO_LOAD_PLAN = "PCO_LOAD_PLAN",
    // Content Library
    GET_CONTENT_PROVIDERS = "GET_CONTENT_PROVIDERS",
    GET_CONTENT_LIBRARY = "GET_CONTENT_LIBRARY",
    GET_PROVIDER_CONTENT = "GET_PROVIDER_CONTENT",
    CHECK_MEDIA_LICENSE = "CHECK_MEDIA_LICENSE",
    // Timecode
    TIMECODE_START = "TIMECODE_START",
    TIMECODE_STOP = "TIMECODE_STOP",
    TIMECODE_VALUE = "TIMECODE_VALUE",
    TIMECODE_AUDIO_DATA = "TIMECODE_AUDIO_DATA",
    TIMECODE_STATUS = "TIMECODE_STATUS",
    // Spotify
    SPOTIFY_GET_STATE = "SPOTIFY_GET_STATE",
    SPOTIFY_COMMAND = "SPOTIFY_COMMAND",
    // FFmpeg Download
    FFMPEG_CHECK = "FFMPEG_CHECK",
    FFMPEG_DOWNLOAD = "FFMPEG_DOWNLOAD"
}

export interface MainSendPayloads {
    // DEV
    [Main.LOG]: any
    /////
    [Main.IMPORT]: { channel: string; format: { name: string; extensions: string[] }; settings?: any }
    [Main.IMPORT_FILES]: { id: string; paths: string[] }
    [Main.BIBLE]: { id: string; name: string }
    [Main.SHOW]: { id: string; name: string }
    [Main.SAVE]: SaveData
    ////////////
    [Main.DELETE_BACKUP]: { path: string }
    [Main.SPELLCHECK]: { addToDictionary?: string; fixSpelling?: string }
    [Main.URL]: string
    [Main.LANGUAGE]: { lang: string; strings: Dictionary }
    [Main.UPDATE_DATA_PATH]: { newPath: string; oldPath: string }
    [Main.LOG_ERROR]: ErrorLog
    [Main.OPEN_FOLDER_PATH]: string
    [Main.GET_STORE_VALUE]: { file: "config" | keyof typeof _store; key: string }
    [Main.SET_STORE_VALUE]: { file: "config" | keyof typeof _store; key: string; value: any }
    [Main.DELETE_SHOWS]: { shows: { id: string; name: string }[] }
    [Main.DELETE_SHOWS_NI]: { shows: TrimmedShows }
    [Main.GET_EMPTY_SHOWS]: { cached: Shows }
    [Main.OUTPUT]: "true" | "false"
    [Main.DOES_MEDIA_EXIST]: { path: string; creationTime?: number; noCache?: boolean }
    [Main.GET_THUMBNAIL]: { input: string; size: number }
    [Main.SAVE_IMAGE]: { id?: string; path?: string; base64?: string; buffer?: ArrayBuffer; filePath?: string[]; format?: "png" | "jpg"; openFolder?: boolean }
    [Main.PDF_TO_IMAGE]: { filePath: string }
    [Main.READ_EXIF]: { id: string }
    [Main.MEDIA_CODEC]: { path: string }
    [Main.MEDIA_TRACKS]: { path: string }
    [Main.DOWNLOAD_LESSONS_MEDIA]: LessonsData[]
    [Main.MEDIA_DOWNLOAD]: { url: string; contentFile?: any }
    [Main.MEDIA_IS_DOWNLOADED]: { url: string; contentFile?: any }
    [Main.NOW_PLAYING]: { filePath: string; name: string; unknownLang: string[]; format: string; duration: number }
    // [Main.MEDIA_BASE64]: { id: string; path: string }[]
    [Main.READ_AUDIO_METADATA]: { filePath: string }
    [Main.CAPTURE_SLIDE]: { output: { [key: string]: Output }; resolution: Resolution }
    [Main.LIBREOFFICE_CONVERT]: { type: string }
    [Main.START_SLIDESHOW]: { path: string; program: string }
    [Main.PRESENTATION_CONTROL]: { action: string }
    [Main.START]: { ports: { [key: string]: number }; max: number; disabled: { [key: string]: boolean }; data: { [key: string]: ServerData } }
    [Main.SERVER_DATA]: { [key: string]: any }
    [Main.WEBSOCKET_START]: number
    [Main.API_TRIGGER]: { action: string; returnId: string; data: any }
    [Main.EMIT_OSC]: { signal: any; data: any }
    [Main.GET_MIDI_OUTPUTS]: string[]
    [Main.GET_MIDI_INPUTS]: string[]
    [Main.SEND_MIDI]: any
    [Main.RECEIVE_MIDI]: any
    [Main.CLOSE_MIDI]: { id: string }
    [Main.GET_LYRICS]: { song: LyricSearchResult }
    [Main.SEARCH_LYRICS]: { artist: string; title: string }
    [Main.RESTORE]?: { path: string }
    [Main.RECORDER]: { blob: ArrayBuffer; name: string }
    [Main.SYSTEM_OPEN]: string

    [Main.LOCATE_MEDIA_FILE]: { filePath: string; folders: string[] }
    [Main.SET_MEDIA_FOLDER_PATH]: string
    [Main.GET_SIMILAR]: { paths: string[] }
    [Main.BUNDLE_MEDIA_FILES]: { openFolder?: boolean; outputPath?: string }
    [Main.MEDIA_FOLDER_COPY]: { paths: string[] }
    [Main.FILE_INFO]: string
    [Main.READ_FOLDER]: { path: string | string[]; depth?: number; generateThumbnails?: boolean; captureFolderContent?: boolean }
    [Main.READ_FILE]: { path: string }
    [Main.OPEN_FOLDER]: { channel: string; title?: string; path?: string }
    [Main.OPEN_FILE]: { id: string; channel: string; title?: string; filter: any; multiple: boolean; read?: boolean }
    // SYNC
    [Main.CAN_SYNC]?: { id: SyncProviderId }
    [Main.GET_TEAMS]?: { id: SyncProviderId }
    [Main.CLOUD_DATA]: { id: SyncProviderId; churchId: string; teamId: string }
    [Main.CLOUD_CHANGED]: { id: SyncProviderId; churchId: string; teamId: string }
    [Main.CLOUD_SYNC]: { id: SyncProviderId; churchId: string; teamId: string; method: "merge" | "read_only" | "upload" | "replace" }
    [Main.RESTORE_CLOUD_BACKUP]: { id: SyncProviderId; churchId: string; teamId: string }
    [Main.GET_CONVERSATION_ID]: { teamId: string }
    [Main.SEND_SOCKET_MESSAGE]: { churchId: string; teamId: string; displayName: string; content: string }
    // Provider-based routing
    [Main.PROVIDER_LOAD_SERVICES]: { providerId: ContentProviderId; cloudOnly?: boolean; data?: any }
    [Main.PROVIDER_DISCONNECT]: { providerId: ContentProviderId; scope?: string }
    [Main.PROVIDER_STARTUP_LOAD]: { providerId: ContentProviderId; scope?: string; data?: any; cloudOnly?: boolean }
    [Main.PROVIDER_FETCH_FOLDERS]: { providerId: ContentProviderId }
    [Main.PCO_LIVE_GET]: { serviceTypeId: string; planId: string }
    [Main.PCO_PUSHER_AUTH]: { socketId: string; channelName: string; serviceTypeId: string }
    [Main.PCO_FETCH_SERVICE_TREE]: undefined
    [Main.PCO_LOAD_PLAN]: { serviceTypeId: string; planId: string }
    // Content Library
    [Main.GET_CONTENT_LIBRARY]: { providerId: ContentProviderId }
    [Main.GET_PROVIDER_CONTENT]: { providerId: ContentProviderId; key: string }
    [Main.CHECK_MEDIA_LICENSE]: { providerId: ContentProviderId; mediaId: string }
    // Timecode
    [Main.TIMECODE_START]: { type: "send" | "receive"; mode: TimecodeMode; framerate?: number; data?: any }
    [Main.TIMECODE_VALUE]: number
    [Main.TIMECODE_STATUS]: "play" | "pause" | "stop"
    [Main.TIMECODE_AUDIO_DATA]: { mode: TimecodeMode; buffer: Uint8Array }
    // Spotify
    [Main.SPOTIFY_GET_STATE]: undefined
    [Main.SPOTIFY_COMMAND]: { command: "playpause" | "next" | "prev" | "seek" | "setVolume" | "pause"; value?: number }
    // FFmpeg
    [Main.FFMPEG_CHECK]: undefined
    [Main.FFMPEG_DOWNLOAD]: undefined
}

export interface MainReturnPayloads {
    // DEV
    [Main.IS_DEV]: boolean
    [Main.GET_CACHE_PATH]: string
    // APP
    [Main.VERSION]: string
    [Main.GET_OS]: OS
    [Main.DEVICE_ID]: string
    [Main.GET_DEVICE_NAME]: string
    [Main.IP]: string[]
    [Main.CHECK_RAM_USAGE]: { total: number; free: number; performanceMode: boolean }
    ///
    // [Main.SAVE]: { closeWhenFinished: boolean; customTriggers: any } | Promise<void>
    [Main.BACKUPS]: { path: string; name: string; date: number; size: number }[]
    [Main.SHOWS]: TrimmedShows
    // STORES
    [Main.SYNCED_SETTINGS]: { [key in SaveListSyncedSettings]: any }
    [Main.STAGE]: StageLayouts
    [Main.PROJECTS]: { projects: Projects; folders: Folders; projectTemplates: Projects }
    [Main.OVERLAYS]: Overlays
    [Main.TEMPLATES]: Templates
    [Main.EVENTS]: { [key: string]: Event }
    [Main.MEDIA]: Media
    [Main.THEMES]: { [key: string]: Themes }
    [Main.DRIVE_API_KEY]: any
    [Main.HISTORY]: { undo: History[]; redo: History[] }
    [Main.USAGE]: any
    [Main.CACHE]: any
    // WINDOW
    [Main.CLOSE]: boolean | void
    [Main.MAXIMIZED]: boolean
    /////////////////////
    [Main.BIBLE]: { id: string; error?: string; content?: [string, Bible] }
    [Main.SHOW]: { id: string; error?: string; content?: [string, Show] }
    ///
    [Main.GET_DISPLAYS]: Display[]
    [Main.GET_PATHS]: MainFilePaths
    [Main.DATA_PATH]: string
    [Main.GET_STORE_VALUE]: any
    [Main.DELETE_SHOWS]: { deleted: string[] }
    [Main.DELETE_SHOWS_NI]: { deleted: string[] } | undefined
    [Main.GET_EMPTY_SHOWS]: Promise<{ id: string; name: string }[] | undefined>
    [Main.FULL_SHOWS_LIST]: string[]
    [Main.GET_SCREENS]: Promise<{ name: string; id: string }[]>
    [Main.GET_WINDOWS]: Promise<{ name: string; id: string }[]>
    [Main.DOES_MEDIA_EXIST]: Promise<{ path: string; exists: boolean; creationTime?: number }>
    [Main.GET_THUMBNAIL]: Promise<{ output: string; input: string; size: number }>
    // [Main.PDF_TO_IMAGE]: Promise<string[]>
    [Main.READ_EXIF]: Promise<{ id: string; exif: ExifData | undefined }>
    [Main.MEDIA_CODEC]: Promise<{ path: string; codecs: string[]; mimeType: string; mimeCodec: string }>
    [Main.MEDIA_TRACKS]: Promise<{ path: string; tracks: Subtitle[] }>
    [Main.MEDIA_IS_DOWNLOADED]: Promise<{ path: string; buffer: Buffer | null; protectedUrl?: string | null; isDownloading?: boolean } | null>
    // [Main.MEDIA_BASE64]: { id: string; content: string }[]
    [Main.READ_AUDIO_METADATA]: Promise<any>
    [Main.CAPTURE_SLIDE]: Promise<{ base64: string } | null>
    [Main.SLIDESHOW_GET_APPS]: string[]
    [Main.GET_MIDI_OUTPUTS]: { name: string }[]
    [Main.GET_MIDI_INPUTS]: { name: string }[]
    [Main.GET_LYRICS]: Promise<{ lyrics: string; source: string; title: string; artist: string }>
    [Main.SEARCH_LYRICS]: Promise<LyricSearchResult[]>
    [Main.GET_SIMILAR]: { path: string; name: string }[]
    [Main.RESTORE_CLOUD_BACKUP]: Promise<{ success: boolean; error?: string }>
    [Main.MEDIA_FOLDER_COPY]: Promise<boolean>
    [Main.LOCATE_MEDIA_FILE]: Promise<{ path: string; hasChanged: boolean } | null>
    [Main.GET_MEDIA_FOLDER_PATH]: string
    [Main.READ_BIBLES_FOLDER]: { path: string; name: string }[]
    [Main.FILE_INFO]: { path: string; stat: Stats; extension: string; folder: boolean } | null
    [Main.READ_FOLDER]: Promise<{ [key: string]: FileFolder }>
    [Main.READ_FILE]: { content: string }
    // SYNC
    [Main.CAN_SYNC]: Promise<boolean>
    [Main.GET_TEAMS]: Promise<{ id: string; churchId: string; name: string }[]>
    [Main.CLOUD_DATA]: Promise<boolean>
    [Main.CLOUD_CHANGED]: Promise<boolean>
    [Main.CLOUD_SYNC]: Promise<{ success?: boolean; error?: string; changedFiles?: any[] }>
    [Main.GET_CONVERSATION_ID]: Promise<string | null>
    [Main.SEND_SOCKET_MESSAGE]: Promise<boolean>
    // Provider-based routing
    [Main.PROVIDER_DISCONNECT]: { success: boolean }
    [Main.PROVIDER_FETCH_FOLDERS]: Promise<PCOFolderTreeNode[]>
    [Main.PCO_FETCH_SERVICE_TREE]: Promise<PCOFolderTreeNode[]>
    [Main.PCO_LIVE_GET]: Promise<{ liveId: string | null; liveChannel: string | null; orgId: string | null; liveStartAt: string | null; liveEndAt: string | null; length: number | null; isPreService: boolean; serviceStartAt: string | null; serviceEndAt: string | null } | null>
    [Main.PCO_PUSHER_AUTH]: Promise<{ auth: string; channel_data?: string } | null>
    // Content Library
    [Main.GET_CONTENT_PROVIDERS]: { providerId: ContentProviderId; displayName: string; hasContentLibrary: boolean }[]
    [Main.GET_CONTENT_LIBRARY]: Promise<ContentLibraryCategory[]>
    [Main.GET_PROVIDER_CONTENT]: Promise<ContentFile[]>
    [Main.CHECK_MEDIA_LICENSE]: Promise<MediaLicense | null>
    // Timecode
    [Main.TIMECODE_VALUE]: number | void
    [Main.TIMECODE_AUDIO_DATA]: Buffer | void
    [Main.TIMECODE_STATUS]: "play" | "pause" | "stop" | void
    // Spotify
    [Main.SPOTIFY_GET_STATE]: Promise<SpotifyState | null>
    [Main.SPOTIFY_COMMAND]: Promise<boolean>
    // FFmpeg
    [Main.FFMPEG_CHECK]: { installed: boolean; path?: string }
    [Main.FFMPEG_DOWNLOAD]: Promise<{ success: boolean; error?: string }>
}

///////////

export type ToMainSendValue2<ID extends Main> = ID extends keyof MainReturnPayloads ? MainReturnPayloads[ID] : never
export type MainSendValue<ID extends Main> = ID extends keyof MainSendPayloads ? MainSendPayloads[ID] : never

export type MainReceiveData<ID extends Main> = ID extends keyof MainSendPayloads ? MainSendPayloads[ID] : undefined
export type MainReceiveValue<ID extends Main = Main> = {
    channel: ID
    data: MainReceiveData<ID>
}

type MainHandler<ID extends Main> = (data: ID extends keyof MainSendPayloads ? MainSendPayloads[ID] : undefined, e: Electron.IpcMainEvent) => ID extends keyof MainReturnPayloads ? MainReturnPayloads[ID] : void
export type MainResponses = {
    [ID in Main]: MainHandler<ID>
}