#!/usr/bin/python
# coding=utf-8
#
# Copyright (C) 2018-2025 by dream-alpha
#
# In case of reuse of this source code please do not remove this copyright.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# For more information on the GNU General Public License see:
# <http://www.gnu.org/licenses/>.


from Components.ActionMap import HelpableActionMap
from Screens.InfoBarGenerics import InfoBarSeek
from enigma import eTimer
from .__init__ import _
from .Debug import logger
from .CutListUtils import secondsToPts, ptsToSeconds
from .BoxUtils import getBoxType


SKIP_TIMEOUT = 5000  # milliseconds
STOP_BEFORE_EOF = 5  # seconds


class CockpitSmartSeek(InfoBarSeek):

	def __init__(self, event_start, config_skip_first_long):
		logger.info("...")
		InfoBarSeek.__init__(self)

		self["InfoBarSmartSeek"] = HelpableActionMap(
			self,
			"InfoBarSmartSeekActions",
			{
				"CHANNELUP":	(self.skipForward,	_("Skip forward")),
				"CHANNELDOWN":	(self.skipBackward,	_("Skip backward")),
			},
			prio=-1
		)

		self.event_start = event_start
		self.skip_first = True
		self.config_skip_first_long = config_skip_first_long
		self.skip_forward = True
		self.skip_index = 0
		self.skip_distance_long = [300, 60, 30, 15]
		self.skip_distance_short = [60, 30, 15]
		self.skip_distance = self.skip_distance_long
		self.reset_skip_timer = eTimer()
		self.reset_skip_timer_conn = self.reset_skip_timer.timeout.connect(self.resetSkipTimer)

	def skipToEventStart(self):
		logger.info("...")
		_, _, _, event_start_time, recording_start_time = self.getEventInfo()
		self.doSkip(event_start_time - recording_start_time)

	def resetSkipTimer(self):
		logger.info("...")
		self.skip_first = True
		self.skip_distance = self.skip_distance_long
		self.skip_index = 0
		self.skip_forward = True
		self.showPVRStatePic(True)

	def setSkipDistance(self):
		if self.skip_first and self.event_start:
			_, _, _, event_start_time, recording_start_time = self.getEventInfo()
			logger.debug("position: %s, event_start_time: %s", ptsToSeconds(self.getPosition()), event_start_time)
			if abs(event_start_time - recording_start_time - ptsToSeconds(self.getSeekPosition())) <= 60:
				self.skip_distance = self.skip_distance_short
			else:
				self.skip_distance = self.skip_distance_long
			logger.debug("skip_distance: %s", self.skip_distance)

	def skipForward(self):
		logger.info("...")
		self.reset_skip_timer.start(SKIP_TIMEOUT, True)
		self.setSkipDistance()
		if not self.skip_first and (not self.skip_forward or (self.config_skip_first_long and self.skip_distance == self.skip_distance_long and self.skip_index == 0)):
			self.skip_index = len(self.skip_distance) - 1 if self.skip_index >= len(self.skip_distance) - 1 else self.skip_index + 1
		self.skip_forward = True
		self.skip_first = False
		distance = self.skip_distance[self.skip_index]
		position = ptsToSeconds(self.getSeekPosition())
		self.showPVRStatePic(False)
		self.doSkip(position + distance)

	def skipBackward(self):
		logger.info("...")
		self.reset_skip_timer.start(SKIP_TIMEOUT, True)
		self.setSkipDistance()
		if not self.skip_first and self.skip_forward:
			self.skip_index = len(self.skip_distance) - 1 if self.skip_index >= len(self.skip_distance) - 1 else self.skip_index + 1
		self.skip_forward = False
		self.skip_first = False
		distance = self.skip_distance[self.skip_index]
		position = ptsToSeconds(self.getSeekPosition())
		distance = min(distance, position)
		self.doSkip(position - distance)

	def doSkip(self, target):
		length = ptsToSeconds(self.getSeekLength())
		if target > length - STOP_BEFORE_EOF:
			target = length - STOP_BEFORE_EOF
		target = max(0, target)
		logger.info("target: %s, length: %s", target, length)
		if length:
			self.doSeek(secondsToPts(target))
		self.showAfterSeek()

	def recoverEoFFailure(self):
		logger.info("skip_forward: %s, skip_index: %s", self.skip_forward, self.skip_index)
		length = ptsToSeconds(self.getSeekLength())
		target = max(0, length - STOP_BEFORE_EOF)
		logger.debug("length: %s, target: %s", length, target)
		if not getBoxType().startswith("dream"):
			self.doSeek(secondsToPts(target))
		else:
			self.doSeekRelative(-secondsToPts(STOP_BEFORE_EOF))