Привет, код программы на пайтон, потом скажу что делать:

import sys
import tempfile
import os
import xml.etree.ElementTree as ET
from PyQt5.QtSvg import QSvgWidget
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import (QApplication, QMainWindow, QAction, QMessageBox, 
                             QVBoxLayout, QWidget, QPushButton, QLabel, QFileDialog, 
                             QDialog, QLineEdit, QStyle, QHBoxLayout, QListWidget, 
                             QListWidgetItem)
from functools import partial 

class IDConflictDialog(QDialog):
    def __init__(self, conflicts, update_function, f1_mod_manager):
        super().__init__()
        self.setWindowTitle("ID conflict has been detected in your database!")
        self.setGeometry(200, 200, 400, 300)

        layout = QVBoxLayout(self)
        
        title_label = QLabel(
            "Please write unique IDs for the following conflicts.<br>"
            "See the list of existing IDs in the database in the tool windows command console.<br>"
            "Regarding calendar_glyph, keep the number order."
        )
        title_label.setStyleSheet("color: black;")
        layout.addWidget(title_label)

        self.inputs = {}
        self.conflicts = conflicts
        for id_tag, default_value in conflicts.items():
            line_edit = QLineEdit(default_value)
            self.inputs[id_tag] = line_edit
            conflict_label = QLabel(f"{id_tag}:")
            conflict_label.setStyleSheet("color: black;")
            layout.addWidget(conflict_label)
            layout.addWidget(line_edit)

        fix_button = QPushButton("FIX IT", self)
        fix_button.clicked.connect(partial(self.fix_conflicts, f1_mod_manager))
        layout.addWidget(fix_button)

    def fix_conflicts(self, f1_mod_manager):
        new_values = {id_tag: line_edit.text() for id_tag, line_edit in self.inputs.items()}

        for id_tag, new_id in new_values.items():
            original_id = self.conflicts[id_tag]
            print(f"Value was changed: Before / {id_tag}: {original_id} / After: {id_tag}: {new_id}")

            if "calender_glyph" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "calender_glyph", original_id, new_id)
            elif "calendar_glyph" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "calendar_glyph", original_id, new_id)
            elif "leaderboard_id" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "leaderboard_id", original_id, new_id)
            elif "track_car_handling" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "ID", original_id, new_id)
            elif "track_fuel_distance" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "ID", original_id, new_id)
            elif "track_difficulties" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "ID", original_id, new_id)
            elif "track_id" in id_tag:
                self.update_specific_tag(f1_mod_manager.temp_custom_file.name, "track_id", original_id, new_id)
            else:
                f1_mod_manager.update_temp_custom_file(id_tag, original_id, new_id)

        QMessageBox.information(self, "Success", "Conflicts resolved and updated in custom track data.")
        self.accept()

    def update_specific_tag(self, file_name, tag_name, original_id, new_id):
        with open(file_name, 'r', encoding='utf-8') as custom_file:
            custom_content = custom_file.readlines()

        with open(file_name, 'w', encoding='utf-8') as custom_file:
            for line in custom_content:
                if tag_name in line and original_id in line:
                    line = line.replace(original_id, new_id)
                custom_file.write(line)

def resource_path(relative_path):
    base_path = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base_path, relative_path)

class F1ModManager(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
        
        self.custom_track_data = None
        self.database_xml = None
        self.temp_custom_file = None
        self.selected_track_id = None
        self.schema_type = None  # Для хранения типа схемы (F12013 или F12014)

    def initUI(self):
        self.setGeometry(100, 100, 800, 600)
        self.setWindowTitle("F1 Track Mod Installer - Beta 1.0 / by AlonsoBeast")

        central_widget = QWidget(self)
        self.setCentralWidget(central_widget)

        main_layout = QHBoxLayout(central_widget)

        left_layout = QVBoxLayout()
        self.track_label = QLabel("F1 2014 TRACK MOD INSTALLER", self)
        self.track_label.setStyleSheet("font-size: 32px; font-family: sans-serif; font-weight: 700; color: #fdfdfd;")
        left_layout.addWidget(self.track_label)

        self.track_mod_label = QLabel("Track Mod:")
        self.track_mod_label.setStyleSheet("font-size: 18px; font-weight: bold; color: #fdfdfd;")
        left_layout.addWidget(self.track_mod_label)

        buttons = [
            ("Import Custom Track Data", self.import_custom_track_data),
            ("Upload your database.xml", self.upload_database_xml),
            ("Check for database conflicts", self.check_for_conflicts),
            ("Save database file as .xml", self.save_database_xml)
        ]

        for text, callback in buttons:
            button = QPushButton(text, self)
            button.setStyleSheet("""
                QPushButton {
                    width: 220px;
                    height: 60px;
                    font-size: 16px;
                    font-weight: 500;
                    background: qlineargradient(spread:pad, x1:1, y1:0, x2:0, y2:1, stop:0 rgb(50, 50, 70), stop:1 rgb(70, 70, 70));
                    color: #fdfdfd;
                    border-radius: 10px; 
                }
                QPushButton:hover {
                    background: qlineargradient(spread:pad, x1:1, y1:0, x2:0, y2:1, stop:0 rgb(60, 60, 80), stop:1 rgb(80, 80, 80));
                    border-radius: 20px; 
                    font-weight: 700;
                }
                QPushButton:last-child {
                    background: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0, stop:0 rgb(221, 58, 70), stop:0.5 rgb(243, 29, 59), stop:1 rgb(252, 176, 69));
                }
                QPushButton:last-child:hover {
                    background: qlineargradient(spread:pad, x1:1, y1:0, x2:0, y2:1, stop:0 rgb(253, 152, 1), stop:1 rgb(221, 58, 70));
                    border-radius: 20px; 
                    font-weight: 700;
                }
            """)
            button.clicked.connect(callback)
            left_layout.addWidget(button)

        left_layout.addStretch()
        main_layout.addLayout(left_layout)

        right_layout = QVBoxLayout()
        self.track_list_label = QLabel("Select a track from the list to install/replace in one of the slots")
        self.track_list_label.setStyleSheet("color: #cbcbcb; font-size: 16px;")
        right_layout.addWidget(self.track_list_label)

        self.track_count_label = QLabel("")
        self.track_count_label.setStyleSheet("color: #cbcbcb; font-size: 16px;")
        right_layout.addWidget(self.track_count_label)

        self.track_list = QListWidget(self)
        self.track_list.setStyleSheet("""
            QListWidget {
                background-color: #1e1d2b;
                color: #ffffff;
                border: none;
                font-size: 16px;
            }
            QListWidget::item {
                background-color: #1e1d2b;
                padding: 10px;
                border-bottom: 1px solid #333;
            }
            QListWidget::item:selected {
                background-color: #ffffff;
                color: #000000;
            }
        """)
        self.track_list.itemClicked.connect(self.on_track_selected)
        right_layout.addWidget(self.track_list)

        main_layout.addLayout(right_layout)

        menubar = self.menuBar()
        fileMenu = menubar.addMenu('File')
        helpMenu = menubar.addMenu('Help')

        newAction = QAction('New', self)
        newAction.triggered.connect(self.new_project)
        fileMenu.addAction(newAction)

        exitAction = QAction('Exit', self)
        exitAction.triggered.connect(self.close)
        fileMenu.addAction(exitAction)

        aboutAction = QAction('About', self)
        aboutAction.triggered.connect(self.show_about)
        helpMenu.addAction(aboutAction)

        self.statusBar().showMessage("Ready")

    def new_project(self):
        self.custom_track_data = None
        self.database_xml = None
        self.selected_track_id = None
        self.schema_type = None
        if self.temp_custom_file and os.path.exists(self.temp_custom_file.name):
            os.remove(self.temp_custom_file.name)
        self.temp_custom_file = None
        self.track_mod_label.setText("Track Mod:")
        self.track_count_label.setText("")
        self.update_track_list()
        self.statusBar().showMessage("New project started")

    def show_about(self):
        QMessageBox.about(self, "About", "Author - AlonsoBeast\nLink to Our Discord Modding Server: https://discord.gg/KXt7NC3Sue")

    def update_track_list(self):
        self.track_list.clear()
        if not self.database_xml:
            self.statusBar().showMessage("Please upload database.xml first.")
            self.track_count_label.setText("")
            return

        try:
            tree = ET.parse(self.database_xml)
            root = tree.getroot()
            ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
            track_models = root.findall(".//ns:track_model", ns) + root.findall(".//ns2:track_model", ns)
            track_fuel_distances = root.findall(".//ns:track_fuel_distance", ns) + root.findall(".//ns2:track_fuel_distance", ns)
            
            track_count = len(track_models)
            self.track_count_label.setText(f"Total of tracks: {track_count}")
            
            if track_count > 40:
                QMessageBox.warning(self, "Warning", "Too many tracks in database.xml (max 40 allowed).")
                return

            for model in track_models:
                id_elem = model.find("ns:id", ns)
                if id_elem is None:
                    id_elem = model.find("ns2:id", ns)
                name_string_id_elem = model.find("ns:name_string_id", ns)
                if name_string_id_elem is None:
                    name_string_id_elem = model.find("ns2:name_string_id", ns)

                if id_elem is not None and name_string_id_elem is not None:
                    id_value = id_elem.text or "Unknown ID"
                    name_value = name_string_id_elem.text or "Unknown Name"
                    item = QListWidgetItem(f"{id_value} | {name_value}")
                    self.track_list.addItem(item)

            if self.custom_track_data and track_count <= 40:
                custom_tree = ET.parse(self.custom_track_data)
                custom_model = custom_tree.find(".//track_model")
                if custom_model is not None:
                    custom_id = custom_model.find("id")
                    custom_name = custom_model.find("name_string_id")
                    if custom_id is not None and custom_name is not None:
                        custom_id_value = custom_id.text or "Unknown ID"
                        custom_name_value = custom_name.text or "Unknown Name"
                        print(f"Debug: Custom track_model - ID: {custom_id_value}, Name: {custom_name_value}")
                        if track_count < 40 and self.selected_track_id is None:
                            custom_item = QListWidgetItem(f"{custom_id_value} | {custom_name_value}")
                            self.track_list.addItem(custom_item)
                            self.track_list.setCurrentItem(custom_item)
                            self.selected_track_id = custom_id_value
                            self.track_mod_label.setText(f"Track Mod: {custom_name_value}")
                        elif self.selected_track_id:
                            is_existing_track = False
                            for model in track_models:
                                existing_id = model.find("ns:id", ns)
                                if existing_id is None:
                                    existing_id = model.find("ns2:id", ns)
                                if existing_id is not None and existing_id.text == self.selected_track_id:
                                    is_existing_track = True
                                    break
                            if is_existing_track:
                                for i in range(self.track_list.count()):
                                    item = self.track_list.item(i)
                                    if item.text().split(" | ")[0] == self.selected_track_id:
                                        item.setText(f"{custom_id_value} | {custom_name_value}")
                                        self.track_mod_label.setText(f"Track Mod: {custom_name_value}")
                                        print(f"Debug: Replaced track_model with ID: {self.selected_track_id} in list")
                                        break

            if track_count == 40 and track_models:
                last_item = self.track_list.item(track_count - 1)
                if last_item:
                    self.track_list.setCurrentItem(last_item)
                    self.selected_track_id = last_item.text().split(" | ")[0]
                    print(f"Debug: Selected last track (ID: {self.selected_track_id}) due to 40 tracks limit")

        except ET.ParseError as e:
            self.statusBar().showMessage(f"Error parsing XML: {str(e)}")

    def on_track_selected(self, item):
        if item:
            text = item.text()
            id_value = text.split(" | ")[0]
            self.selected_track_id = id_value
            item.setSelected(True)
            self.statusBar().showMessage(f"Selected track: {text}")

    def import_custom_track_data(self):
        options = QFileDialog.Options()
        file_name, _ = QFileDialog.getOpenFileName(self, "Select Custom Track Data File", "", "All Files (*)", options=options)
        if file_name:
            self.custom_track_data = file_name
            self.statusBar().showMessage(f"Imported Custom Track Data: {file_name}")

            with open(file_name, 'r', encoding='utf-8') as custom_file:
                custom_content = custom_file.read()
            
            self.temp_custom_file = tempfile.NamedTemporaryFile(delete=False, mode='w', encoding='utf-8')
            self.temp_custom_file.write(custom_content)
            self.temp_custom_file.close()

            custom_tree = ET.parse(file_name)
            custom_model = custom_tree.find(".//track_model")
            if custom_model is not None:
                name_string_id = custom_model.find("name_string_id")
                if name_string_id is not None and name_string_id.text:
                    self.track_mod_label.setText(f"Track Mod: {name_string_id.text}")
            self.update_track_list()

    def upload_database_xml(self):
        options = QFileDialog.Options()
        file_name, _ = QFileDialog.getOpenFileName(self, "Select Database File", "", "All Files (*)", options=options)
        if file_name:
            self.database_xml = file_name
            with open(file_name, 'r', encoding='utf-8') as f:
                content = f.read()
                if 'schemaF12013.xml' in content:
                    self.schema_type = 'F12013'
                elif 'schemaF12014.xml' in content:
                    self.schema_type = 'F12014'
                else:
                    self.schema_type = None
            self.statusBar().showMessage(f"Uploaded Database File: {file_name} (Schema: {self.schema_type or 'Unknown'})")
            self.update_track_list()

    def save_database_xml(self):
        if not self.temp_custom_file or not self.database_xml:
            self.statusBar().showMessage("Please import both data files before saving.")
            return

        try:
            with open(self.temp_custom_file.name, 'r', encoding='utf-8') as custom_file:
                custom_content = custom_file.read()
            with open(self.database_xml, 'r', encoding='utf-8') as database_file:
                database_content = database_file.read()

            custom_blocks = {
                'track': self.extract_block(custom_content, 'track'),
                'track_car_handling': self.extract_block(custom_content, 'track_car_handling'),
                'track_fuel_distance': self.extract_block(custom_content, 'track_fuel_distance'),
                'track_model': self.extract_block(custom_content, 'track_model'),
                'track_difficulties': self.extract_block(custom_content, 'track_difficulties')
            }

            # Модификация track_model в зависимости от схемы
            if custom_blocks['track_model']:
                custom_tree = ET.fromstring(custom_blocks['track_model'])
                if self.schema_type == 'F12013':
                    if custom_tree.find('calendar_glyph') is not None:
                        custom_tree.remove(custom_tree.find('calendar_glyph'))
                    if custom_tree.find('calender_glyph') is None:
                        ET.SubElement(custom_tree, 'calender_glyph').text = '0'  # Значение по умолчанию
                    if custom_tree.find('difficulty') is not None:
                        custom_tree.remove(custom_tree.find('difficulty'))  # Убираем difficulty для F12013
                    # Устанавливаем season как 2013 для F12013
                    season_elem = custom_tree.find('season')
                    if season_elem is not None:
                        season_elem.text = '2013'
                    else:
                        ET.SubElement(custom_tree, 'season').text = '2013'
                elif self.schema_type == 'F12014':
                    if custom_tree.find('calender_glyph') is not None:
                        custom_tree.remove(custom_tree.find('calender_glyph'))
                    if custom_tree.find('calendar_glyph') is None:
                        ET.SubElement(custom_tree, 'calendar_glyph').text = '0'  # Значение по умолчанию
                    if custom_tree.find('difficulty') is None:
                        ET.SubElement(custom_tree, 'difficulty').text = '0'  # Оставляем или добавляем difficulty для F12014
                    # Устанавливаем season как 2014 для F12014
                    season_elem = custom_tree.find('season')
                    if season_elem is not None:
                        season_elem.text = '2014'
                    else:
                        ET.SubElement(custom_tree, 'season').text = '2014'
                custom_blocks['track_model'] = ET.tostring(custom_tree, encoding='unicode')

            # Условие для track_difficulties
            if self.schema_type == 'F12014':
                custom_blocks['track_difficulties'] = ''  # Не добавляем для F12014

            # Модификация ID в track_fuel_distance
            if custom_blocks['track_fuel_distance']:
                # Парсим database.xml для поиска максимального ID в track_fuel_distance
                database_tree = ET.parse(self.database_xml)
                ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                track_fuel_distances = database_tree.findall(".//ns:track_fuel_distance", ns) + \
                                      database_tree.findall(".//ns2:track_fuel_distance", ns)
                
                max_id = 0
                for tf_distance in track_fuel_distances:
                    id_elem = tf_distance.find("ns:ID", ns)
                    if id_elem is None:
                        id_elem = tf_distance.find("ns2:ID", ns)
                    if id_elem is not None and id_elem.text:
                        try:
                            current_id = int(id_elem.text)
                            max_id = max(max_id, current_id)
                        except ValueError:
                            continue
                
                # Устанавливаем новый ID для custom track_fuel_distance
                custom_tf_tree = ET.fromstring(custom_blocks['track_fuel_distance'])
                id_elem = custom_tf_tree.find('ID')
                if id_elem is not None:
                    new_id = max_id + 1
                    id_elem.text = str(new_id)
                    print(f"Debug: Updated track_fuel_distance ID to {new_id} (max ID in database was {max_id})")
                custom_blocks['track_fuel_distance'] = ET.tostring(custom_tf_tree, encoding='unicode')

            # Модификация ID в track_car_handling
            if custom_blocks['track_car_handling']:
                # Парсим database.xml для поиска максимального ID в track_car_handling
                database_tree = ET.parse(self.database_xml)
                ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                track_car_handlings = database_tree.findall(".//ns:track_car_handling", ns) + \
                                     database_tree.findall(".//ns2:track_car_handling", ns)
                
                max_id = 0
                for tc_handling in track_car_handlings:
                    id_elem = tc_handling.find("ns:ID", ns)
                    if id_elem is None:
                        id_elem = tc_handling.find("ns2:ID", ns)
                    if id_elem is not None and id_elem.text:
                        try:
                            current_id = int(id_elem.text)
                            max_id = max(max_id, current_id)
                        except ValueError:
                            continue
                
                # Устанавливаем новый ID для custom track_car_handling
                custom_tc_tree = ET.fromstring(custom_blocks['track_car_handling'])
                id_elem = custom_tc_tree.find('ID')
                if id_elem is not None:
                    new_id = max_id + 1
                    id_elem.text = str(new_id)
                    print(f"Debug: Updated track_car_handling ID to {new_id} (max ID in database was {max_id})")
                custom_blocks['track_car_handling'] = ET.tostring(custom_tc_tree, encoding='unicode')

            # Модификация ID в track_difficulties (только для F12013)
            if custom_blocks['track_difficulties'] and self.schema_type != 'F12014':
                # Парсим database.xml для поиска максимального ID в track_difficulties
                database_tree = ET.parse(self.database_xml)
                ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                track_difficulties = database_tree.findall(".//ns:track_difficulties", ns) + \
                                    database_tree.findall(".//ns2:track_difficulties", ns)
                
                max_id = 0
                for t_difficulty in track_difficulties:
                    id_elem = t_difficulty.find("ns:ID", ns)
                    if id_elem is None:
                        id_elem = t_difficulty.find("ns2:ID", ns)
                    if id_elem is not None and id_elem.text:
                        try:
                            current_id = int(id_elem.text)
                            max_id = max(max_id, current_id)
                        except ValueError:
                            continue
                
                # Устанавливаем новый ID для custom track_difficulties
                custom_td_tree = ET.fromstring(custom_blocks['track_difficulties'])
                id_elem = custom_td_tree.find('ID')
                if id_elem is not None:
                    new_id = max_id + 1
                    id_elem.text = str(new_id)
                    print(f"Debug: Updated track_difficulties ID to {new_id} (max ID in database was {max_id})")
                custom_blocks['track_difficulties'] = ET.tostring(custom_td_tree, encoding='unicode')

            insertion_tags = {
                'track': ['<track_calendar>', '<track_fuel_distance>'],
                'track_car_handling': ['<track_difficulties>', '<track_fuel_distance>'],
                'track_fuel_distance': ['<track_model>', '<track_model>'],
                'track_model': ['<track_stat_value>', '<track_stat_value>'],
                'track_difficulties': ['<track_fuel_distance>', '<track_fuel_distance>']
            }

            for tag, tags in insertion_tags.items():
                insertion_point = -1
                for next_tag in tags:
                    if tag == 'track_fuel_distance' and next_tag == '<track_model>':
                        insertion_point = database_content.find('<track_model>')
                        if insertion_point != -1 and '<default_track_model>' in database_content[:insertion_point]:
                            insertion_point = database_content.find('<track_model>', database_content.find('</default_track_model>') + len('</default_track_model>'))
                    else:
                        insertion_point = database_content.find(next_tag)
                    if insertion_point != -1:
                        break

                if insertion_point != -1 and custom_blocks[tag]:
                    if tag == 'track_difficulties' and '<track_difficulties>' not in database_content:
                        continue

                    if tag == 'track_model':
                        if self.selected_track_id:
                            tree = ET.parse(self.database_xml)
                            root = tree.getroot()
                            ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                            track_models = root.findall(".//ns:track_model", ns) + root.findall(".//ns2:track_model", ns)
                            is_existing_track = False
                            for model in track_models:
                                id_elem = model.find("ns:id", ns)
                                if id_elem is None:
                                    id_elem = model.find("ns2:id", ns)
                                if id_elem is not None and id_elem.text == self.selected_track_id:
                                    is_existing_track = True
                                    break

                            if is_existing_track:
                                start_tag = '<track_model>'
                                end_tag = '</track_model>'
                                search_start = database_content.find(start_tag)
                                while search_start != -1:
                                    search_end = database_content.find(end_tag, search_start) + len(end_tag)
                                    block = database_content[search_start:search_end]
                                    if f'<id>{self.selected_track_id}</id>' in block and '<default_track_model>' not in block:
                                        database_content = database_content[:search_start] + custom_blocks[tag] + database_content[search_end:]
                                        print(f"Debug: Replaced track_model with ID: {self.selected_track_id} in database.xml")
                                        break
                                    search_start = database_content.find(start_tag, search_end)
                            else:
                                tree = ET.fromstring(database_content)
                                ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                                current_track_models = tree.findall(".//ns:track_model", ns) + tree.findall(".//ns2:track_model", ns)
                                if len(current_track_models) < 40:
                                    print(f"Debug: Adding new track_model from custom data (ID: {self.selected_track_id})")
                                    insertion_point = database_content.find('<track_stat_value>')
                                    if insertion_point != -1:
                                        database_content = (
                                            database_content[:insertion_point] +
                                            custom_blocks[tag] +
                                            "\n" +
                                            database_content[insertion_point:]
                                        )
                                        print(f"Debug: Added new track_model before <track_stat_value>")
                                else:
                                    print(f"Debug: Cannot add new track_model — limit of 40 tracks reached")
                        else:
                            tree = ET.fromstring(database_content)
                            ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}
                            current_track_models = tree.findall(".//ns:track_model", ns) + tree.findall(".//ns2:track_model", ns)
                            if len(current_track_models) < 40:
                                print(f"Debug: Adding new track_model from custom data (no selected ID)")
                                insertion_point = database_content.find('<track_stat_value>')
                                if insertion_point != -1:
                                    database_content = (
                                        database_content[:insertion_point] +
                                        custom_blocks[tag] +
                                        "\n" +
                                        database_content[insertion_point:]
                                    )
                                    print(f"Debug: Added new track_model before <track_stat_value>")
                            else:
                                print(f"Debug: Cannot add new track_model — limit of 40 tracks reached")
                    else:
                        if tag == 'track_fuel_distance':
                            if '<default_track_model>' in database_content[:insertion_point]:
                                default_end = database_content.find('</default_track_model>', insertion_point)
                                if default_end != -1:
                                    insertion_point = database_content.find('<track_model>', default_end)
                                    if insertion_point == -1:
                                        continue
                        database_content = (
                            database_content[:insertion_point] +
                            custom_blocks[tag] +
                            "\n" +
                            database_content[insertion_point:]
                        )
                        print(f"Debug: Added {tag} after {next_tag} in database.xml")

            file_name, _ = QFileDialog.getSaveFileName(self, "Save Database File", "", "All Files (*)", options=QFileDialog.Options())
            if file_name:
                with open(file_name, 'w', encoding='utf-8') as output_file:
                    output_file.write(database_content)
                self.statusBar().showMessage(f"Database saved successfully: {file_name}")

        except Exception as e:
            self.statusBar().showMessage(f"Error during integration: {str(e)}")

    @staticmethod
    def extract_block(content, tag):
        start_tag = f'<{tag}>'
        end_tag = f'</{tag}>'
        start_index = content.find(start_tag)
        end_index = content.find(end_tag, start_index) + len(end_tag)
        if start_index != -1 and end_index != -1:
            return content[start_index:end_index]
        return ''

    def check_for_conflicts(self):
        if not self.temp_custom_file or not self.database_xml:
            self.statusBar().showMessage("Please import both data files before checking for conflicts.")
            return

        custom_ids = {
            '<track> ID': None,
            '<track_car_handling> ID': None,
            '<track_fuel_distance> ID': None,
            '<track_model> ID': None,
            '<track_model> leaderboard_id': None,
            '<track_model> calender_glyph': None,
            '<track_model> calendar_glyph': None,
            '<track_model> track_id': None,
            '<track_difficulties> ID': None,
            '<track_difficulties> track': None
        }

        custom_tree = ET.parse(self.temp_custom_file.name)

        for track in custom_tree.findall(".//track"):
            track_id_element = track.find("id")
            if track_id_element is not None and track_id_element.text:
                custom_ids['<track> ID'] = track_id_element.text

        for handling in custom_tree.findall(".//track_car_handling"):
            handling_id_element = handling.find("ID")
            if handling_id_element is None:
                handling_id_element = handling.find("id")
            if handling_id_element is not None and handling_id_element.text:
                custom_ids['<track_car_handling> ID'] = handling_id_element.text

        for distance in custom_tree.findall(".//track_fuel_distance"):
            distance_id_element = distance.find("ID")
            if distance_id_element is None:
                distance_id_element = distance.find("id")
            if distance_id_element is not None and distance_id_element.text:
                custom_ids['<track_fuel_distance> ID'] = distance_id_element.text

        for model in custom_tree.findall(".//track_model"):
            leaderboard_id_element = model.find("leaderboard_id")
            if leaderboard_id_element is not None and leaderboard_id_element.text:
                custom_ids['<track_model> leaderboard_id'] = leaderboard_id_element.text
            
            model_id_element = model.find("id")
            if model_id_element is not None and model_id_element.text:
                custom_ids['<track_model> ID'] = model_id_element.text
            
            calender_glyph_element = model.find("calender_glyph")
            if calender_glyph_element is not None and calender_glyph_element.text:
                custom_ids['<track_model> calender_glyph'] = calender_glyph_element.text
            
            calendar_glyph_element = model.find("calendar_glyph")
            if calendar_glyph_element is not None and calendar_glyph_element.text:
                custom_ids['<track_model> calendar_glyph'] = calendar_glyph_element.text

            track_id_element = model.find("track_id")
            if track_id_element is not None and track_id_element.text:
                custom_ids['<track_model> track_id'] = track_id_element.text

        for difficulties in custom_tree.findall(".//track_difficulties"):
            difficulties_id_element = difficulties.find("ID")
            if difficulties_id_element is None:
                difficulties_id_element = difficulties.find("id")
            if difficulties_id_element is not None and difficulties_id_element.text:
                custom_ids['<track_difficulties> ID'] = difficulties_id_element.text
                
            track_id_element = difficulties.find("track")
            if track_id_element is None:
                track_id_element = difficulties.find("Track")
            if track_id_element is not None and track_id_element.text:
                custom_ids['<track_difficulties> track'] = track_id_element.text

        print(f"Custom IDs: {custom_ids}")

        conflicts = {}
        database_tree = ET.parse(self.database_xml)

        print("Checking for conflicts in the database...")

        ns = {'ns': 'schemaF12013.xml', 'ns2': 'schemaF12014.xml'}

        found_in_db = {
            'track': database_tree.findall(".//ns:track", ns) + database_tree.findall(".//ns2:track", ns),
            'track_car_handling': database_tree.findall(".//ns:track_car_handling", ns) + database_tree.findall(".//ns2:track_car_handling", ns),
            'track_fuel_distance': database_tree.findall(".//ns:track_fuel_distance", ns) + database_tree.findall(".//ns2:track_fuel_distance", ns),
            'track_model': database_tree.findall(".//ns:track_model", ns) + database_tree.findall(".//ns2:track_model", ns),
            'track_difficulties': database_tree.findall(".//ns:track_difficulties", ns) + database_tree.findall(".//ns2:track_difficulties", ns)
        }

        for db_type, elements in found_in_db.items():
            for database_element in elements:
                db_id = database_element.find("ns:id", ns)
                if db_id is None:
                    db_id = database_element.find("ns:ID", ns)

                if db_id is None:
                    db_id = database_element.find("ns2:id", ns)
                    if db_id is None:
                        db_id = database_element.find("ns2:ID", ns)

                if db_id is not None and db_id.text:
                    print(f"Found in database: {database_element.tag} -> {db_id.text}")

                    for id_tag, custom_id in custom_ids.items():
                        if custom_id and db_id.text == custom_id:
                            if f"<{db_type}> ID" in id_tag:
                                conflicts[id_tag] = custom_id
                                print(f"Conflict detected: {id_tag} -> {custom_id}")
                                print(f"Checking ID: {db_id.text} against custom_id: {custom_id} for tag {id_tag}")

                    if db_type == "track_model":
                        leaderboard_id_element = database_element.find("ns:leaderboard_id", ns)
                        if leaderboard_id_element is None:
                            leaderboard_id_element = database_element.find("ns2:leaderboard_id", ns)

                        if leaderboard_id_element is not None and leaderboard_id_element.text:
                            print(f"Found leaderboard_id in database: {leaderboard_id_element.text}")
                            if leaderboard_id_element.text == custom_ids['<track_model> leaderboard_id']:
                                conflicts['<track_model> leaderboard_id'] = custom_ids['<track_model> leaderboard_id']
                                print(f"Conflict detected for leaderboard_id: {custom_ids['<track_model> leaderboard_id']}")

                        calender_glyph_element = database_element.find("ns:calender_glyph", ns)
                        if calender_glyph_element is None:
                            calender_glyph_element = database_element.find("ns2:calender_glyph", ns)

                        if calender_glyph_element is not None and calender_glyph_element.text:
                            print(f"Found calender_glyph in database: {calender_glyph_element.text}")
                            if calender_glyph_element.text == custom_ids['<track_model> calender_glyph']:
                                conflicts['<track_model> calender_glyph'] = custom_ids['<track_model> calender_glyph']
                                print(f"Conflict detected for calender_glyph: {custom_ids['<track_model> calender_glyph']}")

                        calendar_glyph_element = database_element.find("ns:calendar_glyph", ns)
                        if calendar_glyph_element is None:
                            calendar_glyph_element = database_element.find("ns2:calendar_glyph", ns)

                        if calendar_glyph_element is not None and calendar_glyph_element.text:
                            print(f"Found calendar_glyph in database: {calendar_glyph_element.text}")
                            if calendar_glyph_element.text == custom_ids['<track_model> calendar_glyph']:
                                conflicts['<track_model> calendar_glyph'] = custom_ids['<track_model> calendar_glyph']
                                print(f"Conflict detected for calendar_glyph: {custom_ids['<track_model> calendar_glyph']}")

                        track_id_element = database_element.find("ns:track_id", ns)
                        if track_id_element is None:
                            track_id_element = database_element.find("ns2:track_id", ns)

                        if track_id_element is not None and track_id_element.text:
                            print(f"Found track_id in database: {track_id_element.text}")
                            if track_id_element.text == custom_ids['<track_model> track_id']:
                                conflicts['<track_model> track_id'] = custom_ids['<track_model> track_id']
                                print(f"Conflict detected for track_id: {custom_ids['<track_model> track_id']}")

        if conflicts:
            print("Conflicts found: ", conflicts)
            conflict_dialog = IDConflictDialog(conflicts, self.update_temp_custom_file, self)
            conflict_dialog.exec_()
        else:
            QMessageBox.information(self, "No Conflicts", "No ID conflicts found.")

    def update_temp_custom_file(self, id_tag, original_id, new_id):
        with open(self.temp_custom_file.name, 'r', encoding='utf-8') as custom_file:
            custom_content = custom_file.read()

        custom_content = custom_content.replace(original_id, new_id)

        with open(self.temp_custom_file.name, 'w', encoding='utf-8') as custom_file:
            custom_file.write(custom_content)

if __name__ == "__main__":
    print("Welcome to Track Mod Installer by AlonsoBeast!")
    print("Instructions: ")
    print("1. Open the database.bin file in Ego Database Editor by Petar.")
    print("2. Click File - Export as .xml")
    print("3. Load it in the database.xml tab and your modification file with the track in this tool.")
    print("4. Don't forget to check the modification and your database conflicts by ID; if there is a match, replace the number until the conflict is resolved...... ...... . ...")
    print("5. Save the file as database_merged.xml and in the Ego Database Editor tool,")
    print("6. Click the Advanced tab - Merge Database, select your database_merged.xml file.")
    print("7. Enjoy!\n")

    app = QApplication(sys.argv)
    app.setStyleSheet("""
        QMainWindow {
            background-color: #1e1d2b;
            font-family: 'Roboto', sans-serif;
        }
        QLabel {
            color: #cbcbcb;
            font-size: 16px;
        }
        QPushButton {
            background-color: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #ff8a00, stop:1 #e52e71);
            color: #FFFFFF;
            font-size: 16px;
            padding: 10px;
            border-radius: 25px;
        }
        QMenuBar, QStatusBar {
            background-color: #272938;
            color: #FFFFFF;
        }
        QMenuBar::item:selected {
            background-color: #3C3C3C;
        }
        QMenu {
            background-color: #272938;
            color: #FFFFFF;
        }
        QMenu::item:selected {
            background-color: #3C3C3C;
        }
        QMessageBox {
            font-size: 12px;
            font-weight: 200;
            background-color: #1D1D1D;
        }
        QListWidget::item {
            background-color: #1e1d2b;
            color: #ffffff;
            padding: 10px;
            border-bottom: 1px solid #333;
        }
        QListWidget::item:selected {
            background-color: #ffffff;
            color: #000000;
        }
    """)

    window = F1ModManager()
    window.show()
    sys.exit(app.exec_())