ffx/bin/ffx/media_details_screen.py

import os, click, re

from textual import events
from textual.app import App, ComposeResult
from textual.screen import Screen
from textual.widgets import Header, Footer, Static, Button, Input, DataTable
from textual.containers import Grid

from ffx.model.show import Show
from ffx.model.pattern import Pattern

from .pattern_controller import PatternController
from .show_controller import ShowController
from .track_controller import TrackController
from .tag_controller import TagController

from .track_details_screen import TrackDetailsScreen
from .track_delete_screen import TrackDeleteScreen
from .show_details_screen import ShowDetailsScreen
from .pattern_details_screen import PatternDetailsScreen

from ffx.track_type import TrackType
from ffx.model.track import Track

from ffx.track_disposition import TrackDisposition
from ffx.track_descriptor import TrackDescriptor
from ffx.show_descriptor import ShowDescriptor

from textual.widgets._data_table import CellDoesNotExist

from ffx.media_descriptor import MediaDescriptor
from ffx.file_properties import FileProperties

from ffx.helper import DIFF_ADDED_KEY, DIFF_CHANGED_KEY, DIFF_REMOVED_KEY


# Screen[dict[int, str, int]]
class MediaDetailsScreen(Screen):

    CSS = """

    Grid {
        grid-size: 5 8;
        grid-rows: 8 2 2 2 8 2 2 8;
        grid-columns: 25 25 100 10 75;
        height: 100%;
        width: 100%;
        padding: 1;
    }

    Input {
        border: none;
    }
    Button {
        border: none;
    }

    DataTable {
        min-height: 40;
    }

    #toplabel {
        height: 1;
    }
    .two {
        column-span: 2;
    }   
    .three {
        column-span: 3;
    }
    
    .four {
        column-span: 4;
    }
    .five {
        column-span: 5;
    }

    .triple {
        row-span: 3;
    }

    .box {
        height: 100%;
        border: solid green;
    }

    .yellow {
        tint: yellow 40%;
    }

    #differences-table {
        row-span: 8;
        /* tint: magenta 40%; */
    }

    /* #pattern_input {
        tint: red 40%;
    }*/
    """


    BINDINGS = [
        ("n", "new_pattern", "New Pattern"),
        ("u", "update_pattern", "Update Pattern"),
        ("e", "edit_pattern", "Edit Pattern"),
    ]


    def __init__(self):
        super().__init__()

        self.context = self.app.getContext()
        self.Session = self.context['database']['session'] # convenience

        self.__pc = PatternController(context = self.context)
        self.__sc = ShowController(context = self.context)
        self.__tc = TrackController(context = self.context)
        self.__tac = TagController(context = self.context)

        if not 'command' in self.context.keys() or self.context['command'] != 'inspect':
            raise click.ClickException(f"MediaDetailsScreen.__init__(): Can only perform command 'inspect'")
        
        if not 'arguments' in self.context.keys() or not 'filename' in self.context['arguments'].keys() or not self.context['arguments']['filename']:
            raise click.ClickException(f"MediaDetailsScreen.__init__(): Argument 'filename' is required to be provided for command 'inspect'")

        self.__mediaFilename = self.context['arguments']['filename']

        if not os.path.isfile(self.__mediaFilename):
            raise click.ClickException(f"MediaDetailsScreen.__init__(): Media file {self.__mediaFilename} does not exist")

        self.loadProperties()


    def getRowIndexFromShowId(self, showId : int) -> int:
        """Find the index of the row where the value in the specified column matches the target_value."""

        for rowKey, row in self.showsTable.rows.items(): # dict[RowKey, Row]
        
            rowData = self.showsTable.get_row(rowKey)

            try:
                if showId == int(rowData[0]):
                    return int(self.showsTable.get_row_index(rowKey))
            except:
                continue

        return None


    def loadProperties(self):

        self.__mediaFileProperties = FileProperties(self.context, self.__mediaFilename)
        self.__currentMediaDescriptor = self.__mediaFileProperties.getMediaDescriptor()

        #HINT: This is None if the filename did not match anything in database
        self.__currentPattern = self.__mediaFileProperties.getPattern()

        # keine tags vorhanden
        self.__targetMediaDescriptor = self.__currentPattern.getMediaDescriptor(self.context) if self.__currentPattern is not None else None

        # Enumerating differences between media descriptors
        # from file (=current) vs from stored in database (=target)
        try:
            self.__mediaDifferences = self.__targetMediaDescriptor.compare(self.__currentMediaDescriptor) if self.__currentPattern is not None else {}
        except ValueError:
            self.__mediaDifferences = {}


    def updateDifferences(self):

        self.loadProperties()

        self.differencesTable.clear()

        if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():

            currentTags = self.__currentMediaDescriptor.getTags()
            targetTags = self.__targetMediaDescriptor.getTags()

            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
                    row = (f"added media tag: key='{addedTagKey}' value='{targetTags[addedTagKey]}'",)
                    self.differencesTable.add_row(*map(str, row))  

            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
                    row = (f"removed media tag: key='{removedTagKey}' value='{currentTags[removedTagKey]}'",)
                    self.differencesTable.add_row(*map(str, row))

            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
                    row = (f"changed media tag: key='{changedTagKey}' value='{currentTags[changedTagKey]}'->'{targetTags[changedTagKey]}'",)
                    self.differencesTable.add_row(*map(str, row))  

        if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():

            currentTracks = self.__currentMediaDescriptor.getAllTrackDescriptors() # 0,1,2,3
            targetTracks = self.__targetMediaDescriptor.getAllTrackDescriptors() # 0 <- from DB

            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():

                #raise click.ClickException(f"add track {self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]}")
                for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
                    addedTrack : Track = targetTracks[addedTrackIndex]                        
                    row = (f"added {addedTrack.getType().label()} track: index={addedTrackIndex} lang={addedTrack.getLanguage().threeLetter()}",)
                    self.differencesTable.add_row(*map(str, row))  

            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                for removedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY]:
                    row = (f"removed track: index={removedTrackIndex}",)
                    self.differencesTable.add_row(*map(str, row))  

            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                for changedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].keys():

                    changedTrack : Track = targetTracks[changedTrackIndex]
                    changedTrackDiff : dict = self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY][changedTrackIndex]                        

                    if MediaDescriptor.TAGS_KEY in changedTrackDiff.keys():

                        if DIFF_ADDED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
                            for addedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
                                addedTagValue = changedTrack.getTags()[addedTagKey]
                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added key={addedTagKey} value={addedTagValue}",)
                                self.differencesTable.add_row(*map(str, row))  

                        if DIFF_REMOVED_KEY in changedTrackDiff[MediaDescriptor.TAGS_KEY]:
                            for removedTagKey in changedTrackDiff[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed key={removedTagKey}",)
                                self.differencesTable.add_row(*map(str, row))  

                    if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():

                        if DIFF_ADDED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
                            for addedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_ADDED_KEY]:
                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} added disposition={addedDisposition.label()}",)
                                self.differencesTable.add_row(*map(str, row))  

                        if DIFF_REMOVED_KEY in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]:
                            for removedDisposition in changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY][DIFF_REMOVED_KEY]:
                                row = (f"changed {changedTrack.getType().label()} track index={changedTrackIndex} removed disposition={removedDisposition.label()}",)
                                self.differencesTable.add_row(*map(str, row))  


    def on_mount(self):

        if self.__currentPattern is None:
            row = (' ', '<New show>', ' ') # Convert each element to a string before adding
            self.showsTable.add_row(*map(str, row))
    
        for show in self.__sc.getAllShows():
            row = (int(show.id), show.name, show.year) # Convert each element to a string before adding
            self.showsTable.add_row(*map(str, row))

        for mediaTagKey, mediaTagValue in self.__currentMediaDescriptor.getTags().items():
            row = (mediaTagKey, mediaTagValue) # Convert each element to a string before adding
            self.mediaTagsTable.add_row(*map(str, row))

        self.updateTracks()


        if self.__currentPattern is not None:

            showIdentifier = self.__currentPattern.getShowId()
            showRowIndex = self.getRowIndexFromShowId(showIdentifier)
            if showRowIndex is not None:
                self.showsTable.move_cursor(row=showRowIndex)

            self.query_one("#pattern_input", Input).value = self.__currentPattern.getPattern()

            self.updateDifferences()

        else:

            self.query_one("#pattern_input", Input).value = self.__mediaFilename
            self.highlightPattern(True)


    def highlightPattern(self, state : bool):
        if state:
            self.query_one("#pattern_input", Input).styles.background = 'red'
        else:
            self.query_one("#pattern_input", Input).styles.background = None


    def updateTracks(self):

        self.tracksTable.clear()

        trackDescriptorList = self.__currentMediaDescriptor.getAllTrackDescriptors()

        typeCounter = {}

        for td in trackDescriptorList:

            trackType = td.getType()
            if not trackType in typeCounter.keys():
                typeCounter[trackType] = 0

            dispoSet = td.getDispositionSet()

            row = (td.getIndex(),
                    trackType.label(),
                    typeCounter[trackType],
                    td.getAudioLayout().label() if trackType == TrackType.AUDIO else ' ',
                    td.getLanguage().label(),
                    td.getTitle(),
                    'Yes' if TrackDisposition.DEFAULT in dispoSet else 'No',
                    'Yes' if TrackDisposition.FORCED in dispoSet else 'No')

            self.tracksTable.add_row(*map(str, row))

            typeCounter[trackType] += 1


    def compose(self):

        # Create the DataTable widget
        self.showsTable = DataTable(classes="two")

        # Define the columns with headers
        self.column_key_show_id = self.showsTable.add_column("ID", width=10)
        self.column_key_show_name = self.showsTable.add_column("Name", width=50)
        self.column_key_show_year = self.showsTable.add_column("Year", width=10)

        self.showsTable.cursor_type = 'row'


        self.mediaTagsTable = DataTable(classes="two")

        # Define the columns with headers
        self.column_key_track_tag_key = self.mediaTagsTable.add_column("Key", width=20)
        self.column_key_track_tag_value = self.mediaTagsTable.add_column("Value", width=100)

        self.mediaTagsTable.cursor_type = 'row'


        self.tracksTable = DataTable(classes="two")

        # Define the columns with headers
        self.column_key_track_index = self.tracksTable.add_column("Index", width=5)
        self.column_key_track_type = self.tracksTable.add_column("Type", width=10)
        self.column_key_track_sub_index = self.tracksTable.add_column("Subindex", width=5)
        self.column_key_track_layout = self.tracksTable.add_column("Layout", width=10)
        self.column_key_track_language = self.tracksTable.add_column("Language", width=15)
        self.column_key_track_title = self.tracksTable.add_column("Title", width=48)
        self.column_key_track_default = self.tracksTable.add_column("Default", width=8)
        self.column_key_track_forced = self.tracksTable.add_column("Forced", width=8)

        self.tracksTable.cursor_type = 'row'


        # Create the DataTable widget
        self.differencesTable = DataTable(id='differences-table') # classes="triple"

        # Define the columns with headers
        self.column_key_differences = self.differencesTable.add_column("Differences (file->db)", width=70)

        self.differencesTable.cursor_type = 'row'

        yield Header()

        with Grid():

            # 1
            yield Static("Show")
            yield self.showsTable
            yield Static(" ")
            yield self.differencesTable

            # 2
            yield Static(" ")
            yield Button("Substitute", id="pattern_button")
            yield Static(" ", classes="two")

            # 3
            yield Static("Pattern")
            yield Input(type="text", id='pattern_input', classes="two")

            yield Static(" ")
            
            # 4
            yield Static(" ", classes="four")

            # 5
            yield Static("Media Tags")
            yield self.mediaTagsTable
            yield Static(" ")

            # 6
            yield Static(" ", classes="four")

            # 7
            yield Static(" ")
            yield Button("Set Default", id="select_default_button")
            yield Button("Set Forced", id="select_forced_button")
            yield Static(" ")
            # 8
            yield Static("Streams")
            yield self.tracksTable
            yield Static(" ")

        yield Footer()


    def getPatternDescriptorFromInput(self):
        """Returns show id and pattern from corresponding inputs"""
        patternDescriptor = {}
        try:
            patternDescriptor['show_id'] = self.getSelectedShowDescriptor().getId()
            patternDescriptor['pattern'] = str(self.query_one("#pattern_input", Input).value)
        except:
            pass
        return patternDescriptor


    def on_button_pressed(self, event: Button.Pressed) -> None:

        if event.button.id == "pattern_button":

            pattern = self.query_one("#pattern_input", Input).value

            patternMatch = re.search(FileProperties.SE_INDICATOR_PATTERN, pattern)

            if patternMatch:
                self.query_one("#pattern_input", Input).value = pattern.replace(patternMatch.group(1), FileProperties.SE_INDICATOR_PATTERN)


        if event.button.id == "select_default_button":
            selectedTrackDescriptor = self.getSelectedTrackDescriptor()
            self.__currentMediaDescriptor.setDefaultSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
            self.updateTracks()

        if event.button.id == "select_forced_button":
            selectedTrackDescriptor = self.getSelectedTrackDescriptor()
            self.__currentMediaDescriptor.setForcedSubTrack(selectedTrackDescriptor.getType(), selectedTrackDescriptor.getSubIndex())
            self.updateTracks()


    def getSelectedTrackDescriptor(self):
        """Returns a partial track descriptor"""
        try:

            # Fetch the currently selected row when 'Enter' is pressed
            #selected_row_index = self.table.cursor_row
            row_key, col_key = self.tracksTable.coordinate_to_cell_key(self.tracksTable.cursor_coordinate)

            if row_key is not None:
                selected_track_data = self.tracksTable.get_row(row_key)

                kwargs = {}
                kwargs[TrackDescriptor.CONTEXT_KEY] = self.context
                kwargs[TrackDescriptor.INDEX_KEY] = int(selected_track_data[0])
                kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.fromLabel(selected_track_data[1])
                kwargs[TrackDescriptor.SUB_INDEX_KEY] = int(selected_track_data[2])

                return TrackDescriptor(**kwargs)
            else:
                return None

        except CellDoesNotExist:
            return None


    def getSelectedShowDescriptor(self):

        try:
            # Fetch the currently selected row when 'Enter' is pressed
            #selected_row_index = self.table.cursor_row
            row_key, col_key = self.showsTable.coordinate_to_cell_key(self.showsTable.cursor_coordinate)

            if row_key is not None:
                selected_row_data = self.showsTable.get_row(row_key)

                try:
                    kwargs = {}

                    kwargs[ShowDescriptor.ID_KEY] = int(selected_row_data[0])                    
                    kwargs[ShowDescriptor.NAME_KEY] = str(selected_row_data[1])
                    kwargs[ShowDescriptor.YEAR_KEY] = int(selected_row_data[2])

                    return ShowDescriptor(**kwargs)   

                except ValueError:
                    return None

        except CellDoesNotExist:
            return None


    def handle_new_pattern(self, showDescriptor: ShowDescriptor):

        show = (showDescriptor.getId(), showDescriptor.getName(), showDescriptor.getYear())
        self.showsTable.add_row(*map(str, show))

        showRowIndex = self.getRowIndexFromShowId(showDescriptor.getId())
        if showRowIndex is not None:
            self.showsTable.move_cursor(row=showRowIndex)

        patternDescriptor = self.getPatternDescriptorFromInput()
        
        if patternDescriptor:
            patternId = self.__pc.addPattern(patternDescriptor)
            if patternId:
                self.highlightPattern(False)

                for tagKey, tagValue in self.__currentMediaDescriptor.getTags().items():
                    self.__tac.updateMediaTag(patternId, tagKey, tagValue)

                for trackDescriptor in self.__currentMediaDescriptor.getAllTrackDescriptors():
                    self.__tc.addTrack(trackDescriptor, patternId = patternId)


    def action_new_pattern(self):

        try:
            self.__currentMediaDescriptor.checkConfiguration()
        except ValueError:
            return

        selectedShowDescriptor = self.getSelectedShowDescriptor()
        
        #HINT: Callback is invoked after this method has exited. As a workaround the callback is executed directly
        # from here with a mock-up screen result containing the necessary part of keys to perform correctly.
        if selectedShowDescriptor is None:
            self.app.push_screen(ShowDetailsScreen(), self.handle_new_pattern)
        else:
            self.handle_new_pattern(selectedShowDescriptor)


    def action_update_pattern(self):
        """When updating the database the actions must reverse the difference (eq to diff db->file)"""

        if self.__currentPattern is not None:
            patternDescriptor = self.getPatternDescriptorFromInput()
            if (patternDescriptor
                    and self.__currentPattern.getPattern() != patternDescriptor['pattern']):
                return self.__pc.updatePattern(self.__currentPattern.getId(), patternDescriptor)

        self.loadProperties()

        if MediaDescriptor.TAGS_KEY in self.__mediaDifferences.keys():

            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for addedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_ADDED_KEY]:
                    self.__tac.deleteMediaTagByKey(self.__currentPattern.getId(), addedTagKey)

            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for removedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_REMOVED_KEY]:
                    currentTags = self.__currentMediaDescriptor.getTags()
                    self.__tac.updateMediaTag(self.__currentPattern.getId(), removedTagKey, currentTags[removedTagKey])

            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TAGS_KEY].keys():
                for changedTagKey in self.__mediaDifferences[MediaDescriptor.TAGS_KEY][DIFF_CHANGED_KEY]:
                    currentTags = self.__currentMediaDescriptor.getTags()
                    self.__tac.updateMediaTag(self.__currentPattern.getId(), changedTagKey, currentTags[changedTagKey])

        if MediaDescriptor.TRACKS_KEY in self.__mediaDifferences.keys():

            if DIFF_ADDED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():

                for addedTrackIndex in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_ADDED_KEY]:
                    targetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == addedTrackIndex]
                    if targetTracks:
                        self.__tc.deleteTrack(targetTracks[0].getId()) # id

            if DIFF_REMOVED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():
                for removedTrackIndex, removedTrack in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_REMOVED_KEY].items():
                    
                    # Track per inspect/update hinzufügen
                    self.__tc.addTrack(removedTrack, patternId = self.__currentPattern.getId())

            if DIFF_CHANGED_KEY in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY].keys():

                # [vsTracks[tp].getIndex()] = trackDiff
                for changedTrackIndex, changedTrackDiff in self.__mediaDifferences[MediaDescriptor.TRACKS_KEY][DIFF_CHANGED_KEY].items():

                    changedTargetTracks = [t for t in self.__targetMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
                    changedTargeTrackId = changedTargetTracks[0].getId() if changedTargetTracks else None
                    changedTargetTrackIndex = changedTargetTracks[0].getIndex() if changedTargetTracks else None

                    changedCurrentTracks = [t for t in self.__currentMediaDescriptor.getAllTrackDescriptors() if t.getIndex() == changedTrackIndex]
                    # changedCurrentTrackId #HINT: Undefined as track descriptors do not come from file with track_id 

                    if TrackDescriptor.TAGS_KEY in changedTrackDiff.keys():
                        changedTrackTagsDiff = changedTrackDiff[TrackDescriptor.TAGS_KEY]

                        if DIFF_ADDED_KEY in changedTrackTagsDiff.keys():
                            for addedTrackTagKey in changedTrackTagsDiff[DIFF_ADDED_KEY]:

                                if changedTargetTracks:
                                    self.__tac.deleteTrackTagByKey(changedTargeTrackId, addedTrackTagKey)

                        if DIFF_REMOVED_KEY in changedTrackTagsDiff.keys():
                            for removedTrackTagKey in changedTrackTagsDiff[DIFF_REMOVED_KEY]:
                                if changedCurrentTracks:
                                    self.__tac.updateTrackTag(changedTargeTrackId, removedTrackTagKey, changedCurrentTracks[0].getTags()[removedTrackTagKey])

                        if DIFF_CHANGED_KEY in changedTrackTagsDiff.keys():
                            for changedTrackTagKey in changedTrackTagsDiff[DIFF_CHANGED_KEY]:
                                if changedCurrentTracks:
                                    self.__tac.updateTrackTag(changedTargeTrackId, changedTrackTagKey, changedCurrentTracks[0].getTags()[changedTrackTagKey])

                    if TrackDescriptor.DISPOSITION_SET_KEY in changedTrackDiff.keys():
                        changedTrackDispositionDiff = changedTrackDiff[TrackDescriptor.DISPOSITION_SET_KEY]

                        if DIFF_ADDED_KEY in changedTrackDispositionDiff.keys():
                            for changedTrackAddedDisposition in changedTrackDispositionDiff[DIFF_ADDED_KEY]:
                                if changedTargetTrackIndex is not None:
                                    self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackAddedDisposition, False)

                        if DIFF_REMOVED_KEY in changedTrackDispositionDiff.keys():
                            for changedTrackRemovedDisposition in changedTrackDispositionDiff[DIFF_REMOVED_KEY]:
                                if changedTargetTrackIndex is not None:
                                    self.__tc.setDispositionState(self.__currentPattern.getId(), changedTargetTrackIndex, changedTrackRemovedDisposition, True)
                    

        self.updateDifferences()



    def action_edit_pattern(self):
        
        patternDescriptor = {}
        patternDescriptor['show_id'] = self.getSelectedShowDescriptor().getId()
        patternDescriptor['pattern'] = self.getPatternFromInput()

        if patternDescriptor['pattern']:

            selectedPatternId = self.__pc.findPattern(patternDescriptor)
            
            if selectedPatternId is None:
                raise click.ClickException(f"MediaDetailsScreen.action_edit_pattern(): Pattern to edit has no id")

            self.app.push_screen(PatternDetailsScreen(patternId = selectedPatternId, showId = self.getSelectedShowDescriptor().getId()), self.handle_edit_pattern) # <-


    def handle_edit_pattern(self, screenResult):
        self.query_one("#pattern_input", Input).value = screenResult['pattern']
        self.updateDifferences()