# vim: ts=8:sts=8:sw=8:noexpandtab
#
# This file is part of ReText
# Copyright: 2015-2023 Dmitry Shachnev
#
# 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 2 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.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from os.path import exists, splitext
import locale
import time
from markups import get_markup_for_file_name, find_markup_class_by_name
from markups.common import MODULE_HOME_PAGE

from ReText import app_version, globalSettings, converterprocess
from ReText.editor import ReTextEdit
from ReText.highlighter import ReTextHighlighter
from ReText.preview import ReTextPreview

from PyQt6.QtCore import pyqtSignal, Qt, QDir, QFile, QFileInfo, QPoint, QTimer, QUrl
from PyQt6.QtGui import QPalette, QTextCursor, QTextDocument
from PyQt6.QtWidgets import QApplication, QTextEdit, QSplitter, QMessageBox

try:
	from ReText.webenginepreview import ReTextWebEnginePreview
except ImportError:
	ReTextWebEnginePreview = None

PreviewDisabled, PreviewLive, PreviewNormal = range(3)

class ReTextTab(QSplitter):

	fileNameChanged = pyqtSignal()
	modificationStateChanged = pyqtSignal()
	activeMarkupChanged = pyqtSignal()

	# Make _fileName a read-only property to make sure that any
	# modification happens through the proper functions. These functions
	# will make sure that the fileNameChanged signal is emitted when
	# applicable.
	@property
	def fileName(self):
		return self._fileName

	def __init__(self, parent, fileName, previewState=PreviewDisabled):
		super().__init__(Qt.Orientation.Horizontal, parent=parent)
		self.p = parent
		self._fileName = fileName
		self.editBox = ReTextEdit(self)
		self.previewBox = self.createPreviewBox(self.editBox)
		self.activeMarkupClass = None
		self.markup = None
		self.converted = None
		self.previewState = previewState
		self.previewOutdated = False
		self.conversionPending = False
		self.cssFileExists = False
		self.forceDisableAutoSave = False

		self.converterProcess = converterprocess.ConverterProcess()
		self.converterProcess.conversionDone.connect(self.updatePreviewBox)

		textDocument = self.editBox.document()
		self.highlighter = ReTextHighlighter(textDocument)
		if parent.actionEnableSC.isChecked():
			dictionaries, _errors = parent.getSpellCheckDictionaries()
			self.highlighter.dictionaries = dictionaries
			# Rehighlighting is tied to the change in markup class that
			# happens at the end of this function

		self.editBox.textChanged.connect(self.triggerPreviewUpdate)
		self.editBox.undoAvailable.connect(parent.actionUndo.setEnabled)
		self.editBox.redoAvailable.connect(parent.actionRedo.setEnabled)
		self.editBox.copyAvailable.connect(parent.enableCopy)

		# Give both boxes a minimum size so the minimumSizeHint will be
		# ignored when splitter.setSizes is called below
		for widget in self.editBox, self.previewBox:
			widget.setMinimumWidth(125)
			self.addWidget(widget)
		self.setSizes((50, 50))
		self.setChildrenCollapsible(False)

		textDocument.modificationChanged.connect(self.handleModificationChanged)

		self.updateActiveMarkupClass()

	def handleModificationChanged(self):
		self.modificationStateChanged.emit()

	def createPreviewBox(self, editBox):

		# Use closures to avoid a hard reference from ReTextWebEnginePreview
		# to self, which would keep the tab and its resources alive
		# even after other references to it have disappeared.

		def editorPositionToSourceLine(editorPosition):
			viewportPosition = editorPosition - editBox.verticalScrollBar().value()
			sourceLine = editBox.cursorForPosition(QPoint(0,viewportPosition)).blockNumber()
			return sourceLine

		def sourceLineToEditorPosition(sourceLine):
			doc = editBox.document()
			block = doc.findBlockByNumber(sourceLine)
			rect = doc.documentLayout().blockBoundingRect(block)
			return rect.top()

		if ReTextWebEnginePreview and globalSettings.useWebEngine:
			preview = ReTextWebEnginePreview(self,
			                                 editorPositionToSourceLine,
			                                 sourceLineToEditorPosition)
		else:
			preview = ReTextPreview(self)

		return preview

	def getActiveMarkupClass(self):
		'''
		Return the currently active markup class for this tab.
		No objects should be created of this class, it should
		only be used to retrieve markup class specific information.
		'''
		return self.activeMarkupClass

	def updateActiveMarkupClass(self):
		'''
		Update the active markup class based on the default class and
		the current filename. If the active markup class changes, the
		highlighter is rerun on the input text, the markup object of
		this tab is replaced with one of the new class and the
		activeMarkupChanged signal is emitted.
		'''
		previousMarkupClass = self.activeMarkupClass

		self.activeMarkupClass = find_markup_class_by_name(globalSettings.defaultMarkup)

		if self._fileName:
			markupClass = get_markup_for_file_name(
				self._fileName, return_class=True)
			if markupClass:
				self.activeMarkupClass = markupClass

		if self.activeMarkupClass != previousMarkupClass:
			self.highlighter.docType = self.activeMarkupClass.name if self.activeMarkupClass else None
			self.highlighter.rehighlight()

			self.activeMarkupChanged.emit()
			self.triggerPreviewUpdate()

	def getDocumentTitleFromConverted(self, converted):
		if converted:
			try:
				return converted.get_document_title()
			except Exception:
				self.p.printError()

		return self.getBaseName()

	def getBaseName(self):
		if self._fileName:
			fileinfo = QFileInfo(self._fileName)
			basename = fileinfo.completeBaseName()
			return (basename if basename else fileinfo.fileName())
		return self.tr("New document")

	def getHtmlFromConverted(self, converted, includeStyleSheet=True, webenv=False):
		if converted is None:
			markupClass = self.getActiveMarkupClass()
			errMsg = self.tr('Could not parse file contents, check if '
			                 'you have the <a href="%s">necessary module</a> '
			                 'installed!')
			try:
				errMsg %= markupClass.attributes[MODULE_HOME_PAGE]
			except (AttributeError, KeyError):
				# Remove the link if markupClass doesn't have the needed attribute
				errMsg = errMsg.replace('<a href="%s">', '').replace('</a>', '')
			return '<p style="color: red">%s</p>' % errMsg
		headers = ''
		if includeStyleSheet and self.p.ss is not None:
			headers += '<style type="text/css">\n' + self.p.ss + '</style>\n'
		elif includeStyleSheet:
			style = 'td, th { border: 1px solid #c3c3c3; padding: 0 3px 0 3px; }\n'
			style += 'table { border-collapse: collapse; }\n'
			style += 'img { max-width: 100%; }\n'
			# QTextDocument seems to use media=screen even for printing
			if not isinstance(self.previewBox, QTextEdit) and not webenv:
				# https://github.com/retext-project/retext/pull/187
				palette = QApplication.palette()
				fgColor = palette.color(QPalette.ColorRole.Text).name()
				bgColor = palette.color(QPalette.ColorRole.Base).name()
				linkColor = palette.color(QPalette.ColorRole.Link).name()
				visitedLinkColor = palette.color(QPalette.ColorRole.LinkVisited).name()
				style += ('@media screen {\n'
				          f'  html {{ color: {fgColor}; background-color: {bgColor}; }}\n'
				          f'  a, a * {{ color: {linkColor}; }}\n'
				          f'  a:visited, a:visited * {{ color: {visitedLinkColor}; }}\n'
				          '}\n')
				# https://github.com/retext-project/retext/issues/408
				style += '@media print { html { background-color: white; } }\n'
			headers += '<style type="text/css">\n' + style + '</style>\n'
		baseName = self.getBaseName()
		if self.cssFileExists:
			headers += ('<link rel="stylesheet" type="text/css" href="%s.css">\n'
			% baseName)
		headers += ('<meta name="generator" content="ReText %s">\n' % app_version)
		return converted.get_whole_html(
			custom_headers=headers, include_stylesheet=includeStyleSheet,
			fallback_title=baseName, webenv=webenv)

	def getDocumentForExport(self, includeStyleSheet=True, webenv=False):
		markupClass = self.getActiveMarkupClass()
		if markupClass and markupClass.available():
			exportMarkup = markupClass(filename=self._fileName)

			text = self.editBox.toPlainText()
			converted = exportMarkup.convert(text)
		else:
			converted = None

		return (self.getDocumentTitleFromConverted(converted),
		        self.getHtmlFromConverted(converted, includeStyleSheet=includeStyleSheet, webenv=webenv),
			self.previewBox)

	def updatePreviewBox(self):
		self.conversionPending = False

		try:
			self.converted = self.converterProcess.get_result()
		except converterprocess.MarkupNotAvailableError:
			self.converted = None
		except converterprocess.ConversionError:
			return self.p.printError()

		if isinstance(self.previewBox, QTextEdit):
			scrollbar = self.previewBox.verticalScrollBar()
			scrollbarValue = scrollbar.value()
			# If scrollbar was not on top, save its distance to bottom so that
			# it will be restored in previewBox.updateScrollPosition() later.
			if scrollbarValue:
				self.previewBox.distToBottom = scrollbar.maximum() - scrollbarValue
			else:
				self.previewBox.distToBottom = None
		try:
			html = self.getHtmlFromConverted(self.converted)
		except Exception:
			return self.p.printError()
		self.previewBox.setFont(globalSettings.getPreviewFont())
		if isinstance(self.previewBox, QTextEdit):
			self.previewBox.lastRenderTime = time.time()
			self.previewBox.setHtml(html)
			self.previewBox.updateScrollPosition(scrollbar.minimum(),
			                                     scrollbar.maximum())
		else:
			# Always provide a baseUrl otherwise QWebView will
			# refuse to show images or other external objects
			if self._fileName:
				baseUrl = QUrl.fromLocalFile(self._fileName)
			else:
				baseUrl = QUrl.fromLocalFile(QDir.currentPath())
			self.previewBox.setHtml(html, baseUrl)

		if self.previewOutdated:
			self.triggerPreviewUpdate()

	def triggerPreviewUpdate(self):
		self.previewOutdated = True
		if self.previewState == PreviewDisabled:
			return

		if not self.conversionPending:
			self.conversionPending = True
			QTimer.singleShot(500, self.startPendingConversion)

	def startPendingConversion(self):
		self.previewOutdated = False

		requested_extensions = ['ReText.mdx_posmap'] if globalSettings.syncScroll else []
		self.converterProcess.start_conversion(self.getActiveMarkupClass().name,
		                                       self.fileName,
		                                       requested_extensions,
		                                       self.editBox.toPlainText(),
		                                       QDir.currentPath())

	def updateBoxesVisibility(self):
		self.editBox.setVisible(self.previewState < PreviewNormal)
		self.previewBox.setVisible(self.previewState > PreviewDisabled)

	def rebuildPreviewBox(self):
		self.previewBox.disconnectExternalSignals()
		self.previewBox.setParent(None)
		self.previewBox.deleteLater()
		self.previewBox = self.createPreviewBox(self.editBox)
		self.previewBox.setMinimumWidth(125)
		self.addWidget(self.previewBox)
		self.setSizes((50, 50))
		self.triggerPreviewUpdate()
		self.updateBoxesVisibility()

	def detectEncoding(self, raw: bytes):
		'''
		Detect content encoding of the given data.

		It will return None if it can't determine the encoding.
		'''
		try:
			import chardet
		except ImportError:
			return

		result = chardet.detect(raw)
		if result['confidence'] > 0.9:
			if result['encoding'].lower() == 'ascii':
				# UTF-8 files can be falsely detected as ASCII files if they
				# don't contain non-ASCII characters in first 2048 bytes.
				# We map ASCII to UTF-8 to avoid such situations.
				return 'utf-8'
			return result['encoding']

	def readTextFromFile(self, fileName=None, encoding=None):
		previousFileName = self._fileName
		fileName = fileName or self._fileName

		try:
			with open(fileName, 'rb') as openfile:
				data = openfile.read()
		except OSError as ex:
			QMessageBox.warning(self, '', str(ex))
			return

		# Only try to detect encoding if it is not specified
		if encoding is None and globalSettings.detectEncoding:
			encoding = self.detectEncoding(data[:2048])
		encoding = encoding or globalSettings.defaultCodec or None

		try:
			text = data.decode(encoding or locale.getpreferredencoding(False))
		except (UnicodeDecodeError, LookupError) as ex:
			QMessageBox.warning(self, '', str(ex))
			return

		if encoding:
			# If encoding is specified or detected, we should save the file with
			# the same encoding
			self.editBox.document().setProperty("encoding", encoding)

		self._fileName = fileName
		if previousFileName != self._fileName:
			self.updateActiveMarkupClass()

		self.forceDisableAutoSave = False
		self.editBox.setPlainText(text)
		self.editBox.document().setModified(False)
		self.handleModificationChanged()

		cssFileName = self.getBaseName() + '.css'
		self.cssFileExists = QFile.exists(cssFileName)

		if previousFileName != self._fileName:
			self.fileNameChanged.emit()

	def writeTextToFile(self, fileName=None):
		# Just writes the text to file, without any changes to tab object
		# Used directly for e.g. export extensions

		# Get text from the cursor to avoid tweaking special characters,
		# see https://bugreports.qt.io/browse/QTBUG-57552 and
		# https://github.com/retext-project/retext/issues/216
		cursor = self.editBox.textCursor()
		cursor.select(QTextCursor.SelectionType.Document)
		text = cursor.selectedText().replace('\u2029', '\n')

		fileName = fileName or self._fileName
		encoding = self.editBox.document().property("encoding")
		encoding = encoding or globalSettings.defaultCodec or None
		try:
			data = text.encode(encoding or locale.getpreferredencoding(False))
		except (UnicodeEncodeError, LookupError) as ex:
			QMessageBox.warning(self, '', str(ex))
			return False
		try:
			with open(fileName, 'wb') as savefile:
				savefile.write(data)
		except OSError as ex:
			QMessageBox.warning(self, '', str(ex))
			return False
		return True

	def saveTextToFile(self, fileName=None):
		# Sets fileName as tab fileName and writes the text to that file
		if self._fileName:
			self.p.fileSystemWatcher.removePath(self._fileName)
		result = self.writeTextToFile(fileName)
		if result:
			self.forceDisableAutoSave = False
			self.editBox.document().setModified(False)
			self.p.fileSystemWatcher.addPath(fileName or self._fileName)
			if fileName and self._fileName != fileName:
				self._fileName = fileName
				self.updateActiveMarkupClass()
				self.fileNameChanged.emit()

		return result

	def goToLine(self,line):
		block = self.editBox.document().findBlockByLineNumber(line)
		if block.isValid():
			newCursor = QTextCursor(block)
			self.editBox.setTextCursor(newCursor)

	def find(self, text, flags, replaceText=None, wrap=False):
		if self.previewState == PreviewNormal and replaceText is None:
			return self.previewBox.findText(text, flags)
		cursor = self.editBox.textCursor()
		if wrap and flags & QTextDocument.FindFlag.FindBackward:
			cursor.movePosition(QTextCursor.MoveOperation.End)
		elif wrap:
			cursor.movePosition(QTextCursor.MoveOperation.Start)
		if replaceText is not None and cursor.selectedText() == text:
			newCursor = cursor
		else:
			newCursor = self.editBox.document().find(text, cursor, flags)
		if not newCursor.isNull():
			if replaceText is not None:
				newCursor.insertText(replaceText)
				newCursor.movePosition(QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.MoveAnchor, len(replaceText))
				newCursor.movePosition(QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, len(replaceText))
			self.editBox.setTextCursor(newCursor)
			if self.editBox.cursorRect().bottom() >= self.editBox.height() - 3:
				scrollValue = self.editBox.verticalScrollBar().value()
				areaHeight = self.editBox.fontMetrics().height()
				self.editBox.verticalScrollBar().setValue(scrollValue + areaHeight)
			return True
		if not wrap:
			return self.find(text, flags, replaceText, True)
		return False

	def replaceAll(self, text, replaceText):
		cursor = self.editBox.textCursor()
		cursor.beginEditBlock()
		cursor.movePosition(QTextCursor.MoveOperation.Start)
		flags = QTextDocument.FindFlag(0)
		cursor = lastCursor = self.editBox.document().find(text, cursor, flags)
		while not cursor.isNull():
			cursor.insertText(replaceText)
			lastCursor = cursor
			cursor = self.editBox.document().find(text, cursor, flags)
		if not lastCursor.isNull():
			lastCursor.movePosition(QTextCursor.MoveOperation.Left, QTextCursor.MoveMode.MoveAnchor, len(replaceText))
			lastCursor.movePosition(QTextCursor.MoveOperation.Right, QTextCursor.MoveMode.KeepAnchor, len(replaceText))
			self.editBox.setTextCursor(lastCursor)
		self.editBox.textCursor().endEditBlock()
		return not lastCursor.isNull()

	def openSourceFile(self, linkPath):
		"""Finds and opens the source file for link target fileToOpen.

		When links like [test](test) are clicked, the file test.md is opened.
		It has to be located next to the current opened file.
		Relative paths like [test](../test) or [test](folder/test) are also possible.
		"""

		fileToOpen = self.resolveSourceFile(linkPath)
		if exists(fileToOpen) and get_markup_for_file_name(fileToOpen, return_class=True):
			self.p.openFileWrapper(fileToOpen)
			return fileToOpen
		if get_markup_for_file_name(fileToOpen, return_class=True):
			if not QFile.exists(fileToOpen) and QFileInfo(fileToOpen).dir().exists():
				if self.promptFileCreation(fileToOpen):
					self.p.openFileWrapper(fileToOpen)
					return fileToOpen

	def promptFileCreation(self, fileToCreate):
		"""
		Prompt user if a file should be created for the clicked link,
		and try to create it. Return True on success.
		"""
		buttonReply = QMessageBox.question(self, self.tr('Create missing file?'),
		                                   self.tr("The file '%s' does not exist.\n\nDo you want to create it?") % fileToCreate,
		                                   QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
		                                   QMessageBox.StandardButton.No)
		if buttonReply == QMessageBox.StandardButton.Yes:
			return self.createFile(fileToCreate)
		elif buttonReply == QMessageBox.StandardButton.No:
			return False

	def resolveSourceFile(self, linkPath):
		"""
		Finds the actual path of the file to open in a new tab.
		When the link has no extension, eg: [Test](test), the extension of the current file is assumed
		(eg test.md for a markdown file).
		When the link is an html file eg: [Test](test.html), the extension of the current file is assumed
		(eg test.md for a markdown file).
		Relative paths like [test](../test) or [test](folder/test) are also possible.
		"""
		basename, ext = splitext(linkPath)
		if self.fileName:
			currentExt = splitext(self.fileName)[1]
			if ext in ('.html', '') and (exists(basename+currentExt) or not exists(linkPath)):
				ext = currentExt

		return basename+ext

	def createFile(self, fileToCreate):
		"""Try to create file, return True if successful"""
		try:
			# Create file:
			open(fileToCreate, 'x').close()
			return True
		except OSError as err:
			QMessageBox.warning(self, self.tr("File could not be created"),
			                    self.tr("Could not create file '%s': %s") % (fileToCreate, err))
			return False

	def autoSaveActive(self) -> bool:
		return (globalSettings.autoSave
		        and not self.forceDisableAutoSave
		        and self.fileName is not None
		        and QFileInfo(self.fileName).isWritable())
