--[[
SOURCE_ https://github.com/deus0ww/mpv-conf/blob/master/scripts/Thumbnailer.lua
COMMIT_ 20211005 62fa158

搭配osc_lazy的缩略图脚本(1)/(2)
]]--

local ipairs,loadfile,pairs,pcall,tonumber,tostring = ipairs,loadfile,pairs,pcall,tonumber,tostring
local debug,io,math,os,string,table,utf8 = debug,io,math,os,string,table,utf8
local min,max,floor,ceil,huge = math.min,math.max,math.floor,math.ceil,math.huge
local mp      = require 'mp'
local msg     = require 'mp.msg'
local opt     = require 'mp.options'
local utils   = require 'mp.utils'

local script_name = mp.get_script_name()

local message = {
	worker = {
		registration  = 'tn_worker_registration',
		reset         = 'tn_worker_reset',
		queue         = 'tn_worker_queue',
		start         = 'tn_worker_start',
		progress      = 'tn_worker_progress',
		finish        = 'tn_worker_finish',
	},
	osc = {
		registration  = 'tn_osc_registration',
		reset         = 'tn_osc_reset',
		update        = 'tn_osc_update',
		finish        = 'tn_osc_finish',
	},
	debug = 'Thumbnailer-debug',

	manual_start = script_name .. '-start',
	manual_stop  = script_name .. '-stop',
	manual_show  = script_name .. '-show',
	manual_hide  = script_name .. '-hide',
	toggle_gen   = script_name .. '-toggle-gen',
	toggle_osc   = script_name .. '-toggle-osc',
	double       = script_name .. '-double',
	shrink       = script_name .. '-shrink',
	enlarge      = script_name .. '-enlarge',
	auto_delete  = script_name .. '-toggle-auto-delete',

	queued     = 1,
	processing = 2,
	ready      = 3,
	failed     = 4,
}


-----------
-- Utils --
-----------
local OS_MAC, OS_WIN, OS_NIX = 'MAC', 'WIN', 'NIX'
local function get_os()
	if jit and jit.os then
		if jit.os == 'Windows' then return OS_WIN
		elseif jit.os == 'OSX' then return OS_MAC
		else return OS_NIX end
	end
	if (package.config:sub(1,1) ~= '/') then return OS_WIN end
	local res = mp.command_native({ name = 'subprocess', args = {'uname', '-s'}, playback_only = false, capture_stdout = true, capture_stderr = true, })
	return (res and res.stdout and res.stdout:lower():find('darwin') ~= nil) and OS_MAC or OS_NIX
end
local OPERATING_SYSTEM = get_os()

local function format_json(tab)
	local json, err = utils.format_json(tab)
	if err then msg.error('Formatting JSON failed:', err) end
	if json then return json else return '' end
end

local function parse_json(json)
	local tab, err = utils.parse_json(json, true)
	if err then msg.error('Parsing JSON failed:', err) end
	if tab then return tab else return {} end
end

local function is_empty(...) -- Not for tables
	if ... == nil then return true end
	for _, v in ipairs({...}) do
		if (v == nil) or (v == '') or (v == 0) then return true end
	end
	return false
end


-------------------------------------
-- External Process and Filesystem --
-------------------------------------
local function subprocess_result(sub_success, result, mpv_error, subprocess_name, start_time)
	local cmd_status, cmd_stdout, cmd_stderr, cmd_error, cmd_killed
	if result then cmd_status, cmd_stdout, cmd_stderr, cmd_error, cmd_killed = result.status, result.stdout, result.stderr, result.error_string, result.killed_by_us end
	local cmd_status_success, cmd_status_string, cmd_err_success, cmd_err_string, success
	
	if     cmd_status == 0      then cmd_status_success, cmd_status_string = true,  'ok'
	elseif is_empty(cmd_status) then cmd_status_success, cmd_status_string = true,  '_'
	elseif cmd_status == 124 or cmd_status == 137 or cmd_status == 143 then -- timer: timed-out(124), killed(128+9), or terminated(128+15)
	                                 cmd_status_success, cmd_status_string = false, 'timed out'
	else                             cmd_status_success, cmd_status_string = false, ('%d'):format(cmd_status) end
	
	if     is_empty(cmd_error)   then cmd_err_success, cmd_err_string = true,  '_'
	elseif cmd_error == 'init'   then cmd_err_success, cmd_err_string = false, 'failed to initialize'
	elseif cmd_error == 'killed' then cmd_err_success, cmd_err_string = false, cmd_killed and 'killed by us' or 'killed, but not by us'
	else                              cmd_err_success, cmd_err_string = false, cmd_error end
	
	if is_empty(cmd_stdout) then cmd_stdout = '_' end
	if is_empty(cmd_stderr) then cmd_stderr = '_' end
	subprocess_name = subprocess_name or '_'
	start_time = start_time or os.time()
	success = (sub_success == nil or sub_success) and is_empty(mpv_error) and cmd_status_success and cmd_err_success

	if success then msg.debug('Subprocess', subprocess_name, 'succeeded. | Status:', cmd_status_string, '| Time:', ('%ds'):format(os.difftime(os.time(), start_time)))
	else            msg.error('Subprocess', subprocess_name, 'failed. | Status:', cmd_status_string, '| MPV Error:', mpv_error or 'n/a', 
	                          '| Subprocess Error:', cmd_err_string, '| Stdout:', cmd_stdout, '| Stderr:', cmd_stderr) end
	return success, cmd_status_string, cmd_err_string, cmd_stdout, cmd_stderr
end

local function run_subprocess(command, name)
	if not command then return false end
	local subprocess_name, start_time = name or command[1], os.time()
	-- msg.debug('Subprocess', subprocess_name, 'Starting...')
	local result, mpv_error = mp.command_native( {name='subprocess', args=command, playback_only = false, capture_stdout = true, capture_stderr = true} )
	local success, _, _, _ = subprocess_result(nil, result, mpv_error, subprocess_name, start_time)
	return success
end

local function run_subprocess_async(command, name)
	if not command then return false end
	local subprocess_name, start_time = name or command[1], os.time()
	-- msg.debug('Subprocess', subprocess_name, 'Starting (async)...')
	mp.command_native_async( {name='subprocess', args=command, playback_only = false, capture_stdout = true, capture_stderr = true}, function(s, r, e) subprocess_result(s, r, e, subprocess_name, start_time) end )
	return nil
end

local function join_paths(...)
	local sep = OPERATING_SYSTEM == OS_WIN and '\\' or '/'
	local result = ''
	for _, p in ipairs({...}) do
		result = (result == '') and p or result .. sep .. p
	end
	return result
end

local function file_exists(path)
	local file = io.open(path, 'rb')
	if not file then return false end
	local _, _, code = file:read(1)
	file:close()
	return code == nil
end

local function exec_exist(name, exec_path)
	local delim = ':'
	if OPERATING_SYSTEM == OS_WIN then delim, name = ';', name .. '.exe' end
	local env_path = exec_path ~= '' and exec_path or ((os.getenv('PWD') or mp.get_property('working-directory')) .. delim .. os.getenv('PATH'))
	msg.debug('PATH: ' .. env_path)
	for path_dir in env_path:gmatch('[^'..delim..']+') do
		if file_exists(join_paths(path_dir, name)) then return true end
	end
	msg.debug(name .. 'not found.')
	return false
end

local function dir_exist(path)
	local ok, _, _ = os.rename(path .. '/', path .. '/')
	if not ok then return false end
	local file = io.open(join_paths(path, 'test'), 'w')
	if file then 
		file:close()
		return os.remove(join_paths(path, 'test'))
	end
	return false
end

local function create_dir(path)
	return dir_exist(path) or run_subprocess( OPERATING_SYSTEM == OS_WIN and {'cmd', '/e:on', '/c', 'mkdir', path} or {'mkdir', '-p', path} )
end

local function delete_dir(path)
	if is_empty(path) then return end
	msg.warn('Deleting Dir:', path)
	return run_subprocess( OPERATING_SYSTEM == OS_WIN and {'cmd', '/e:on', '/c', 'rd', '/s', '/q', path} or {'rm', '-r', path} )
end


--------------------
-- Data Structure --
--------------------
local initialized        = false
local default_cache_dir  = join_paths(OPERATING_SYSTEM == OS_WIN and os.getenv('TEMP') or '/tmp/', script_name)
local saved_state, state

local user_opts = {
	-- General
	auto_gen              = true,               -- Auto generate thumbnails
	auto_show             = true,               -- Show thumbnails by default
	auto_delete           = 0,                  -- Delete the thumbnail cache. Use at your own risk. 0=No, 1=On file close, 2=When quiting
	start_delay           = 2,                  -- Delay the start of the thumbnailer (seconds)

	-- Paths
	cache_dir             = default_cache_dir,  -- Note: Files are not cleaned afterward, by default
	worker_script_path    = '',                 -- Only needed if the script can't auto-locate the file to load more workers
	exec_path             = '',                 -- This is appended to PATH to search for mpv, ffmpeg, and other executables.

	-- Thumbnail
	dimension             = 320,                -- Max width and height before scaling
	thumbnail_count       = 120,                -- Try to create this many thumbnails within the delta limits below
	min_delta             = 5,                  -- Minimum time between thumbnails (seconds)
	max_delta             = 60,                 -- Maximum time between thumbnails (seconds)
	remote_delta_factor   = 2,                  -- Multiply delta by this for remote sources
	stream_delta_factor   = 2,                  -- Multiply delta by this for streams (youtube, etc)
	bitrate_delta_factor  = 2,                  -- Multiply delta by this for high bitrate sources
	bitrate_threshold     = 8,                  -- The threshold to consider a source to be high bitrate (Mbps)
	
	-- OSC
	spacer                = 2,                  -- Size of borders and spacings
	show_progress         = 1,                  -- Display the thumbnail-ing progress. (0=never, 1=while generating, 2=always)
	centered              = false,              -- Center the thumbnail on screen
	update_time           = 0.5,                -- Fastest time interval between updating the OSC with new thumbnails

	-- Worker
	max_workers           = 3,                  -- Number of active workers. Must have at least one copy of the worker script alongside this script.
	worker_remote_factor  = 0.5,                -- Multiply max_workers by this for remote streams or when MPV enables cache
	worker_bitrate_factor = 0.5,                -- Multiply max_workers by this for high bitrate sources. Set threshold with bitrate_threshold
	worker_delay          = 0.5,                -- Delay between starting workers (seconds)
	worker_timeout        = 4,                  -- Timeout before killing encoder. 0=No Timeout (Linux or Mac w/ coreutils installed only). Standardized at 720p and linearly scaled with resolution.
	accurate_seek         = false,              -- Use accurate timing instead of closest keyframe for thumbnails. (Slower)
	use_ffmpeg            = false,              -- Use FFMPEG when appropriate. FFMPEG must be in PATH or in the MPV directory
	prefer_ffmpeg         = false,              -- Use FFMPEG when available
	ffmpeg_threads        = 8,                  -- Limit FFMPEG/MPV LAVC threads per worker. Also limits filter and output threads for FFMPEG.
	ffmpeg_scaler         = 'bilinear',         -- ffmpeg软件缩放算法 https://ffmpeg.org/ffmpeg-scaler.html
	mpv_scaler            = 'bilinear',         -- mpv软件缩放算法
	mpv_hwdec             = 'no',               -- mpv硬解码
	ffmpeg_hwaccel        = 'none',             -- ffmpeg硬解码
	ffmpeg_hwaccel_device = '0',                -- ffmpeg硬解码设备
}

local thumbnails, thumbnails_new,thumbnails_new_count

local function reset_thumbnails()
	thumbnails           = {}
	thumbnails_new       = {}
	thumbnails_new_count = 0
end

------------
-- Worker --
------------
local workers, workers_indexed, workers_timers = {}, {}, {}
local workers_started, workers_finished, workers_finished_indexed, timer_start, timer_total

local function workers_reset()
	for _, timer in ipairs(workers_timers) do timer:kill() end
	workers_timers           = {}
	workers_started          = false
	workers_finished         = {}
	workers_finished_indexed = {}
	timer_start              = 0
	timer_total              = 0
	for _, worker in ipairs(workers_indexed) do
		mp.command_native({'script-message-to', worker, message.worker.reset})
	end
end

local function worker_set_options()
	return {
		encoder               = (not state.is_remote and user_opts.use_ffmpeg and exec_exist('ffmpeg', user_opts.exec_path)) and 'ffmpeg' or 'mpv',
		exec_path             = user_opts.exec_path,
		worker_timeout        = state.worker_timeout,
		accurate_seek         = user_opts.accurate_seek,
		use_ffmpeg            = user_opts.use_ffmpeg,
		ffmpeg_threads        = user_opts.ffmpeg_threads,
		ffmpeg_scaler         = user_opts.ffmpeg_scaler,
		mpv_scaler            = user_opts.mpv_scaler,
		mpv_hwdec             = user_opts.mpv_hwdec,
		ffmpeg_hwaccel        = user_opts.ffmpeg_hwaccel,
		ffmpeg_hwaccel_device = user_opts.ffmpeg_hwaccel_device,
	}
end

local function workers_queue()
	local worker_data = {
		state          = state,
		worker_options = worker_set_options(),
	}
	local start_time_index = 0
	for i, worker in ipairs(workers_indexed) do
		if i > state.max_workers then break end
		worker_data.start_time_index = start_time_index
		mp.command_native_async({'script-message-to', worker, message.worker.queue, format_json(worker_data)}, function() end)
		start_time_index = ceil(i * state.tn_per_worker)
	end
end

local function workers_start()
	timer_start = os.time()
	if state.cache_dir and state.cache_dir ~= '' then os.remove(join_paths(state.cache_dir, 'stop')) end
	for i, worker in ipairs(workers_indexed) do
		if i > state.max_workers then break end
		table.insert(workers_timers, mp.add_timeout( user_opts.worker_delay * i^0.8, function() mp.command_native({'script-message-to', worker, message.worker.start}) end))
	end
	workers_started = true
end

local function workers_stop()
	if state and state.cache_dir and state.cache_dir ~= '' then
		local file = io.open(join_paths(state.cache_dir, 'stop'), 'w')
		if file then file:close() end
	end
	if timer_total and timer_start then timer_total = timer_total + os.difftime(os.time(), timer_start) end
	timer_start = 0
end

local function workers_are_stopped()
	if not initialized or not workers_started then return true end
	local file = io.open(join_paths(state.cache_dir, 'stop'), 'r')
	if not file then return false end
	file:close()
	return true
end


---------
-- OSC --
---------
local osc_name, osc_opts, osc_stats, osc_visible, osc_last_update

local function osc_reset_stats()
	osc_stats = {
		queued         = 0,
		processing     = 0,
		ready          = 0,
		failed         = 0,
		total          = 0,
		total_expected = 0,
		percent        = 0,
		timer          = 0,
	}
end

local function osc_reset()
	osc_reset_stats()
	osc_last_update = 0
	osc_visible = nil
	if osc_name then mp.command_native({'script-message-to', osc_name, message.osc.reset}) end
end

local function osc_set_options(is_visible)
	osc_visible = (is_visible == nil) and user_opts.auto_show or is_visible
	return {
		spacer        = user_opts.spacer,
		show_progress = user_opts.show_progress,
		scale         = state.scale,
		centered      = user_opts.centered,
		visible       = osc_visible,
	}
end

local function osc_update(ustate, uoptions, uthumbnails)
	if is_empty(osc_name) then return end
	local osc_data  = {
		state       = ustate,
		osc_options = uoptions,
		thumbnails  = uthumbnails,
	}
	if osc_data.thumbnails then
		osc_stats.timer          = timer_start == 0 and timer_total or (timer_total + os.difftime(os.time(), timer_start))
		osc_stats.total_expected = floor(state.duration / state.delta) + 1
		osc_data.osc_stats       = osc_stats
	else
		osc_data.osc_stats = nil
	end
	mp.command_native_async({'script-message-to', osc_name, message.osc.update, format_json(osc_data)}, function() end)
end

local function osc_delta_update(flush)
	local time_since_last_update = os.clock() - osc_last_update
	if thumbnails_new_count <= 0 then return end
	if (time_since_last_update >= (4.00 * user_opts.update_time)) or 
	   (time_since_last_update >= (2.00 * user_opts.update_time) and thumbnails_new_count >= state.worker_buffer) or
	   (time_since_last_update >= (1.00 * user_opts.update_time) and thumbnails_new_count >= state.osc_buffer) or
	   thumbnails_new_count >= floor(state.tn_per_worker - 1) or
	   flush
	then
		osc_update(nil, nil, thumbnails_new)
		thumbnails_new = {}
		thumbnails_new_count = 0
		osc_last_update = os.clock()
	end
end

local osc_full_update_timer  = mp.add_periodic_timer((4.00 * user_opts.update_time), function() osc_update(nil, nil, thumbnails) end)
osc_full_update_timer:kill()
local osc_delta_update_timer = mp.add_periodic_timer((0.25 * user_opts.update_time), function() osc_delta_update() end)
osc_delta_update_timer:kill()

local count_existing = {
	[message.queued]     = function() osc_stats.queued     = osc_stats.queued     - 1 end,
	[message.processing] = function() osc_stats.processing = osc_stats.processing - 1 end,
	[message.failed]     = function() osc_stats.failed     = osc_stats.failed     - 1 end,
	[message.ready]      = function() osc_stats.ready      = osc_stats.ready      - 1 end,
}
local count_new = {
	[message.queued]     = function() osc_stats.queued     = osc_stats.queued     + 1 end,
	[message.processing] = function() osc_stats.processing = osc_stats.processing + 1 end,
	[message.failed]     = function() osc_stats.failed     = osc_stats.failed     + 1 end,
	[message.ready]      = function() osc_stats.ready      = osc_stats.ready      + 1 end,
}

local function osc_update_count(time_string, status)
	local osc_stats, existing = osc_stats, thumbnails[time_string]
	if existing then count_existing[existing]() else osc_stats.total = osc_stats.total + 1 end
	if status   then count_new[status]()        else osc_stats.total = osc_stats.total - 1 end
	osc_stats.percent = osc_stats.total > 0 and (osc_stats.failed + osc_stats.ready) / osc_stats.total or 0
end


----------------
-- Core Logic --
----------------
local stop_conditions

local worker_script_path

local function create_workers()
	local workers_requested = (state and state.max_workers) and state.max_workers or user_opts.max_workers
	msg.debug('Workers Available:', #workers_indexed)
	msg.debug('Workers Requested:', workers_requested)
	msg.debug('worker_script_path:', worker_script_path)
	local missing_workers = workers_requested - #workers_indexed
	if missing_workers > 0 and worker_script_path ~= nil and worker_script_path ~= '' then
		for _ = 1, missing_workers do
			-- msg.debug('Recruiting Worker...')
			mp.command_native({'load-script', worker_script_path})
		end
	end
end

local function hash_string(filepath, filename)
	if OPERATING_SYSTEM == OS_WIN then return filename end
	local command
	if     exec_exist('shasum', user_opts.exec_path)     then command = {user_opts.exec_path .. 'shasum', '-a', '256', filepath}
	elseif exec_exist('gsha256sum', user_opts.exec_path) then command = {user_opts.exec_path .. 'gsha256sum', filepath}
	elseif exec_exist('sha256sum', user_opts.exec_path)  then command = {user_opts.exec_path .. 'sha256sum', filepath} end
	if not command then return filename end -- checksum command unavailable
	local res = mp.command_native({name = 'subprocess', args = command, playback_only = false, capture_stdout = true, capture_stderr = true,})
	return (res and res.stdout) and res.stdout or filename
end

local function create_ouput_dir(filepath, filename, dimension, rotate)
	local name, basepath, success, max_char = '', '', false, 64

	-- Try path without two-bytes UTF-8 char and only alphanumerics
	name = filename:gsub('[\192-\255][\128-\191]*', ''):gsub('[^%w]+', ''):sub(1, max_char)
	msg.debug('Creating Output Dir: Trying', name)
	if not is_empty(name) then
		basepath = join_paths(user_opts.cache_dir, name)
		success = create_dir(basepath)
	end
	
	if not success then  -- Try hashed path
		name = hash_string(filepath, filename):sub(1, max_char)
		msg.debug('Creating Output Dir: Trying', name)
		basepath = join_paths(user_opts.cache_dir, name)
		success = create_dir(basepath)
	end
	
	if not success then  -- Failed
		msg.error('Creating Output Dir: Failed', name)
		return {basepath = nil, fullpath = nil}
	end
	msg.debug('Creating Output Dir: Using ', name)
	
	local fullpath = join_paths(basepath, dimension, rotate)
	if not create_dir(fullpath) then return { basepath = nil, fullpath = nil } end
	return {basepath = basepath, fullpath = fullpath}
end

local function calculate_timing(is_remote)
	local duration, file_size  = mp.get_property_native('duration', 0), mp.get_property_native('file-size', 0)
	if duration == 0 then return { duration = 0, delta = huge, high_bitrate = false } end
	local delta_target   = duration / (user_opts.thumbnail_count - 1)
	local saved_factor   = saved_state.delta_factor or 1
	local remote_factor  = is_remote and user_opts.remote_delta_factor or 1
	local stream_factor  = file_size == 0 and user_opts.stream_delta_factor or 1
	local high_bitrate   = (file_size / duration) >= (user_opts.bitrate_threshold * 131072)
	local bitrate_factor = high_bitrate and user_opts.bitrate_delta_factor or 1
	local delta = max(user_opts.min_delta, min(user_opts.max_delta, delta_target)) * saved_factor * remote_factor * stream_factor * bitrate_factor
	return { duration = duration, delta = delta, high_bitrate = high_bitrate }
end

local function calculate_scale()
	local hidpi_scale = mp.get_property_native('display-hidpi-scale', 1.0)
	if osc_opts then
		local scale = (saved_state.fullscreen ~= nil and saved_state.fullscreen) and osc_opts.scalefullscreen or osc_opts.scalewindowed
		return scale * hidpi_scale
	else
		return hidpi_scale
	end
end

local function calculate_geometry(scale)
	local geometry = { dimension = 0, width = 0, height = 0, scale = 0, rotate = 0, is_rotated = false }
	local video_params = saved_state.video_params
	local dimension = floor(saved_state.size_factor * user_opts.dimension * scale + 0.5)
	if not video_params or is_empty(video_params.dw, video_params.dh) or dimension <= 0 then return geometry end
	local width, height = dimension, dimension
	if video_params.dw > video_params.dh then
		height = floor(width  * video_params.dh / video_params.dw + 0.5)
	else
		width  = floor(height * video_params.dw / video_params.dh + 0.5)
	end
	geometry.dimension, geometry.width, geometry.height, geometry.dw, geometry.dh = dimension, width, height, video_params.dw, video_params.dh
	if not video_params.rotate then return geometry end
	geometry.rotate     = (video_params.rotate - saved_state.initial_rotate) % 360
	geometry.is_rotated = not ((((video_params.rotate - saved_state.initial_rotate) % 180) ~= 0) == saved_state.meta_rotated) --xor
	return geometry
end

local function calculate_worker_limit(duration, delta, is_remote, is_high_bitrate)
	local remote_factor  = is_remote and user_opts.worker_remote_factor or 1
	local bitrate_factor = is_high_bitrate and user_opts.worker_bitrate_factor or 1
	return max(floor(min(user_opts.max_workers, duration / delta) * remote_factor * bitrate_factor), 1)
end

local function calculate_worker_timeout(width, height, is_remote, is_high_bitrate)
	if user_opts.worker_timeout == 0 then return 0 end
	local worker_timeout = ((width * height) / 921600) * user_opts.worker_timeout
	if is_remote       then worker_timeout = worker_timeout * 2 end
	if is_high_bitrate then worker_timeout = worker_timeout * 2 end
	return ceil(worker_timeout)
end

local function has_video()
	local track_list = mp.get_property_native('track-list', {})
	if is_empty(track_list) then return false end
	for _, track in ipairs(track_list) do
		if track.type == 'video' and not track.external and not track.albumart then return true end
	end
	return false
end

local function state_init()
	local input_fullpath  = saved_state.input_fullpath
	local input_filename  = saved_state.input_filename
	local cache_format    = '%.5d'
	local cache_extension = '.bgra'
    local is_remote       = (input_fullpath:find('://') ~= nil) and mp.get_property_native('demuxer-via-network', false)
	local timing          = calculate_timing(is_remote)
	local scale           = calculate_scale()
	local geometry        = calculate_geometry(scale)
	local meta_rotated    = saved_state.meta_rotated
	local cache_dir       = create_ouput_dir(input_fullpath, input_filename, geometry.dimension, geometry.rotate)
	local worker_timeout  = calculate_worker_timeout(geometry.width, geometry.height, is_remote, timing.is_high_bitrate)
	local max_workers     = calculate_worker_limit(timing.duration, timing.delta, is_remote, timing.is_high_bitrate)
	local tn_max          = floor(timing.duration / timing.delta) + 1
	local tn_per_worker   = tn_max / max_workers
	local worker_buffer   = 2
	local osc_buffer      = worker_buffer * max_workers

	-- Global State
	state = {
		cache_dir       = cache_dir.fullpath,
		cache_dir_base  = cache_dir.basepath,
		cache_format    = cache_format,
		cache_extension = cache_extension,
		input_fullpath  = input_fullpath,
		input_filename  = input_filename,
		duration        = timing.duration,
		delta           = timing.delta,
		width           = geometry.width,
		height          = geometry.height,
		dw              = geometry.dw,
		dh              = geometry.dh,
		scale           = scale,
		rotate          = geometry.rotate,
		meta_rotated    = meta_rotated,
		is_rotated      = geometry.is_rotated,
		is_remote       = is_remote,
		tn_max          = tn_max,
		tn_per_worker   = tn_per_worker,
		max_workers     = max_workers,
		worker_timeout  = worker_timeout,
		worker_buffer   = worker_buffer,
		osc_buffer      = osc_buffer,
	}
	stop_conditions = {
		is_seekable = mp.get_property_native('seekable', true),
		has_video   = has_video(),
	}

	if is_empty(worker_script_path) then worker_script_path = user_opts.worker_script_path end
	create_workers()
	initialized = true
end

local function saved_state_init()
	local rotate = mp.get_property_native('video-params/rotate', 0)
	saved_state = {
		input_fullpath = mp.get_property_native('path', ''),
		input_filename = mp.get_property_native('filename/no-ext', ''):gsub('watch%?v=', ''),
		meta_rotated   = ((rotate % 180) ~= 0),
		initial_rotate = rotate % 360,
		delta_factor   = 1.0,
		size_factor    = 1.0,
		fullscreen     = mp.get_property_native("fullscreen", false)
	}
end

local function is_thumbnailable()
	-- Must catch all cases that's not thumbnail-able and anything else that may crash the OSC.
	if not (state and stop_conditions) then return false end
	for key, value in pairs(state) do
		if key == 'rotate'         and value then goto continue end
		if key == 'worker_buffer'  and value then goto continue end
		if key == 'osc_buffer'     and value then goto continue end
		if key == 'worker_timeout' and value then goto continue end
		if is_empty(value) then
			msg.warn('Stopping - State Incomplete:', key, value)
			return false
		end
		::continue::
	end
	for condition, value in pairs(stop_conditions) do		
		if not value then 
			msg.warn('Stopping:', condition, value)
			return false 
		end
	end
	return true
end

local auto_delete = nil

local function delete_cache_dir()
	if auto_delete == nil then auto_delete = user_opts.auto_delete end
	if auto_delete > 0 then 
		local path = user_opts.cache_dir
		msg.debug('Clearing Cache on Shutdown:', path)
		if path:len() < 16 then return end
		delete_dir(path)
	end
end

local function delete_cache_subdir()
	if not state then return end
	if auto_delete == nil then auto_delete = user_opts.auto_delete end
	if auto_delete == 1 then
		local path = state.cache_dir_base
		msg.debug('Clearing Cache for File:', path)
		if path:len() < 16 then return end
		delete_dir(path)
	end
end

local function reset_all(keep_saved, keep_osc_data)
	initialized = false
	osc_full_update_timer:kill()
	osc_delta_update_timer:kill()
	workers_stop()
	workers_reset()
	reset_thumbnails()
	opt.read_options(user_opts, script_name)
	if not keep_saved or not saved_state then saved_state_init() end
	if not keep_osc_data then osc_reset() else osc_reset_stats() end
	msg.debug('Reset (' .. (keep_saved and 'Soft' or 'Hard') .. ', ' .. (keep_osc_data and 'OSC-Partial' or 'OSC-All') .. ')')
end

local function run_generation(paused)
	if not initialized or not is_thumbnailable() then return end
	if #workers_indexed < state.max_workers or not osc_name or not osc_opts then
		mp.add_timeout(0.1, function() run_generation(paused) end)
	else
		workers_queue()
		if not paused then
			workers_start()
			osc_delta_update_timer:resume()
		end
	end
end

local function stop() 
	workers_stop()
	osc_delta_update_timer:kill()
	osc_delta_update(true)
end

local function start(paused)
	if not initialized then mp.add_timeout(user_opts.start_delay, function() 
			state_init()
			start(paused)
		end)
	end
	if is_thumbnailable() then
		osc_update(state, osc_set_options(osc_visible), nil)
		run_generation(paused)
	end
end

local function osc_set_visibility(is_visible)
	if is_visible and not initialized then start(true) end
	if osc_name then osc_update(nil, osc_set_options(is_visible), nil) end
end


--------------
-- Bindings --
--------------
-- Binding - Manual Start
mp.register_script_message(message.manual_start, start)

-- Binding - Manual Stop
mp.register_script_message(message.manual_stop, stop)

-- Binding - Toggle Generation
mp.register_script_message(message.toggle_gen, function() if workers_are_stopped() then start() else stop() end end)

-- Binding - Manual Show OSC
mp.register_script_message(message.manual_show, function() osc_set_visibility(true) end)

-- Binding - Manual Hide OSC
mp.register_script_message(message.manual_hide, function() osc_set_visibility(false) end)

-- Binding - Toggle Visibility
mp.register_script_message(message.toggle_osc,  function() osc_set_visibility(not osc_visible) end)

-- Binding - Double Frequency
mp.register_script_message(message.double, function()
	if not initialized or not saved_state or not saved_state.delta_factor then return end
	local target = max(0.25, saved_state.delta_factor * 0.5)
	if tostring(saved_state.delta_factor) ~= tostring(target) then
		saved_state.delta_factor = target
		reset_all(true, true)
		start()
	end
end)

local function resize(target)
	if tostring(saved_state.size_factor) ~= tostring(target) then
		saved_state.size_factor = target
		reset_all(true)
		start()
	end
end

-- Binding - Shrink
mp.register_script_message(message.shrink, function()
	if initialized and saved_state and saved_state.size_factor then resize(max(0.2, saved_state.size_factor - 0.2)) end
end)

-- Binding - Enlarge
mp.register_script_message(message.enlarge, function()
	if initialized and saved_state and saved_state.size_factor then resize(min(2.0, saved_state.size_factor + 0.2)) end
end)

-- Binding - Toggle Auto Delete
local auto_delete_message = { [0] = '', [1] = ' (on file close)', [2] = ' (on quit)' }
mp.register_script_message(message.auto_delete, function()
	if auto_delete == nil then auto_delete = user_opts.auto_delete end
	auto_delete = (auto_delete + 1) % 3
	mp.osd_message( (auto_delete > 0 and '■' or '□') .. ' Thumbnail Auto Delete' .. auto_delete_message[auto_delete])
end)


------------
-- Events --
------------
-- On Video Params Change
mp.observe_property('video-params', 'native', function(_, video_params)
	if not video_params or is_empty(video_params.dw, video_params.dh) then return end
	if not saved_state or (saved_state.input_fullpath ~= mp.get_property_native('path', '')) then
		delete_cache_subdir()
		reset_all()
		saved_state.video_params = video_params
		start(not user_opts.auto_gen)
		return
	end
	if initialized and saved_state and saved_state.video_params and saved_state.video_params.rotate and video_params.rotate and tostring(saved_state.video_params.rotate) ~= tostring(video_params.rotate) then
		reset_all(true)
		saved_state.video_params = video_params
		start()
		return
	end
end)

-- On Fullscreen Change
mp.observe_property('fullscreen', 'native', function(_, fullscreen)
	if (fullscreen == nil) or (not osc_opts or osc_opts.scalewindowed == osc_opts.scalefullscreen) then return end
	if initialized and saved_state then
		reset_all(true)
		saved_state.fullscreen = fullscreen
		start()
		return
	end
end)

-- On file close
mp.register_event('end-file', delete_cache_subdir)

-- On Shutdown
mp.register_event('shutdown', delete_cache_dir)


-------------------
-- Workers & OSC --
-------------------
-- Listen for OSC Registration
mp.register_script_message(message.osc.registration, function(json)
	local osc_reg = parse_json(json)
	if osc_reg and osc_reg.script_name and osc_reg.osc_opts and not (osc_name and osc_opts) then
		osc_name = osc_reg.script_name
		osc_opts = osc_reg.osc_opts
		msg.debug('OSC Registered:', utils.to_string(osc_reg))
	else
		msg.warn('OSC Not Registered:', utils.to_string(osc_reg))
	end
end)

-- Listen for OSC Finish
mp.register_script_message(message.osc.finish, function()
	msg.debug('OSC: Finished.')
	osc_delta_update_timer:kill()
	osc_full_update_timer:kill()
end)

-- Listen for Worker Registration
mp.register_script_message(message.worker.registration, function(new_reg)
	local worker_reg = parse_json(new_reg)
	if worker_reg.name and not workers[worker_reg.name] then
		workers[worker_reg.name] = true
		workers_indexed[#workers_indexed + 1] = worker_reg.name
		if (is_empty(worker_script_path)) and not is_empty(worker_reg.script_path) then
			worker_script_path = worker_reg.script_path
			create_workers()
			msg.debug('Worker Script Path Recieved:', worker_script_path)
		end
		msg.debug('Worker Registered:', worker_reg.name)
	else
		msg.warn('Worker Not Registered:', worker_reg.name)
	end
end)

-- Listen for Worker Progress Report
mp.register_script_message(message.worker.progress, function(json)
	local new_progress = parse_json(json)
	if new_progress.input_filename ~= state.input_filename then return end
	for time_string, new_status in pairs(new_progress.thumbnail_map) do
		if thumbnails_new[time_string] ~= new_status then
			thumbnails_new[time_string] = new_status
			thumbnails_new_count = thumbnails_new_count + 1
		end
		osc_update_count(time_string, new_status)
		thumbnails[time_string] = new_status
	end
end)

-- Listen for Worker Finish
mp.register_script_message(message.worker.finish, function(json)
	local worker_stats = parse_json(json)
	if worker_stats.name and worker_stats.queued == 0 and not workers_finished[worker_stats.name] then
		workers_finished[worker_stats.name] = true
		workers_finished_indexed[#workers_finished_indexed + 1] = worker_stats.name
		msg.debug('Worker Finished:', worker_stats.name, json)
	else
		msg.warn('Worker Finished (uncounted):', worker_stats.name, json)
	end
	if #workers_finished_indexed >= state.max_workers then
		msg.debug('All Workers: Finished.')
		osc_delta_update_timer:kill()
		osc_delta_update(true)
		osc_full_update_timer:resume()
	end
end)


-----------
-- Debug --
-----------
mp.register_script_message(message.debug, function()
	msg.info('============')
	msg.info('Video Stats:')
	msg.info('============')
	msg.info('video-params', utils.to_string(mp.get_property_native('video-params', {})))
	msg.info('video-dec-params', utils.to_string(mp.get_property_native('video-dec-params', {})))
	msg.info('video-out-params', utils.to_string(mp.get_property_native('video-out-params', {})))
	msg.info('track-list', utils.to_string(mp.get_property_native('track-list', {})))
	msg.info('duration', mp.get_property_native('duration', 0))
	msg.info('file-size', mp.get_property_native('file-size', 0))
	msg.info('auto_delete', auto_delete)
	
	msg.info('============================')
	msg.info('Thumbnailer Internal States:')
	msg.info('============================')
	msg.info('saved_state:', state and utils.to_string(saved_state) or 'nil')
	msg.info('state:', state and utils.to_string(state) or 'nil')
	msg.info('stop_conditions:', stop_conditions and utils.to_string(stop_conditions) or 'nil')
	msg.info('user_opts:', user_opts and utils.to_string(user_opts) or 'nil')
	msg.info('worker_script_path:', worker_script_path and worker_script_path or 'nil')
	msg.info('osc_name:', osc_name and osc_name or 'nil')
	msg.info('osc_stats:', osc_stats and utils.to_string(osc_stats) or 'nil')
	msg.info('thumbnails:', thumbnails and utils.to_string(thumbnails) or 'nil')
	msg.info('thumbnails_new:', thumbnails_new and utils.to_string(thumbnails_new) or 'nil')
	msg.info('workers:', workers and utils.to_string(workers) or 'nil')
	msg.info('workers_indexed:', workers_indexed and utils.to_string(workers_indexed) or 'nil')
	msg.info('workers_finished:', workers_finished and utils.to_string(workers_finished) or 'nil')
	msg.info('workers_finished_indexed:', workers_finished_indexed and utils.to_string(workers_finished_indexed) or 'nil')
end)