widgets.py

from PyQt5.QtWidgets import (QStackedLayout,QVBoxLayout,QHBoxLayout,QFormLayout,QComboBox,QLineEdit,QApplication, QMainWindow,QWidget, QLabel,QPushButton,QFrame,QSizePolicy)
from PyQt5.QtWidgets import (QMenu,QTreeView, QFileSystemModel,QFileIconProvider,QSplitter, QMessageBox,QTabWidget,QTabBar,QScrollArea,QTextEdit,QListWidget,QListWidgetItem,QAbstractItemView,QGraphicsDropShadowEffect,QTableWidget,QTableWidgetItem,QHeaderView)

from PyQt5.QtGui import QColor,QIcon,QPixmap, QTextCursor,QIntValidator,QDoubleValidator,QStandardItemModel,QStandardItem,QPainter,QDrag,QFont,QTextCharFormat,QBrush
from PyQt5.QtCore import QPoint,QDir,Qt,QModelIndex,QSize,QFileInfo,QPropertyAnimation,QObject,pyqtSignal,QThread,QEvent,QMimeData,QSortFilterProxyModel
import sys
import json
import time
import traceback
from func import *
import func

THEMES = {
    'macOS':   {'view_board': 'macos',  'command_block': 'minimal'},
    'Windows': {'view_board': 'win',    'command_block': 'macos'},
    'Colors':  {'view_board': 'colors', 'command_block': 'minimal'},
    'Carbon':  {'view_board': 'carbon', 'command_block': 'minimal'},
    'Office':  {'view_board': 'office', 'command_block': 'minimal'},
}

def _load_theme_from_prefs():
    try:
        with open(os.path.join(CURRENT_PATH, 'preferences.json'), 'r') as f:
            name = json.load(f).get('theme', 'macOS')
            return name if name in THEMES else 'macOS'
    except (FileNotFoundError, ValueError, KeyError):
        return 'macOS'

CURRENT_THEME = _load_theme_from_prefs()
ICON_STYLE_VB = THEMES[CURRENT_THEME]['view_board']
ICON_STYLE_CB = THEMES[CURRENT_THEME]['command_block']

def _load_icon_set_from_prefs():
    try:
        with open(os.path.join(CURRENT_PATH, 'preferences.json'), 'r') as f:
            return json.load(f).get('icon_set', 'cloud')
    except (FileNotFoundError, ValueError, KeyError):
        return 'cloud'

ICON_SET = _load_icon_set_from_prefs()

# basic widgets
class CodeLine(QWidget):
    def __init__(self,text:str='CodeLine'):
        super().__init__()
        self.setObjectName("CodeLine")
        ICON_SIZE = 15

        self._text = text
        self._current_args = None 

        layout = QHBoxLayout()
        layout.setAlignment(Qt.AlignLeft)
        layout.setSpacing(1)

        # play button
        BUTTON_STYLE = f"""
            QPushButton {{
                background-color: {CONFIG["Controls"]["background-color"]}; 
                padding: {ICON_SIZE/4}px;
                width: {ICON_SIZE}px;
                height: {ICON_SIZE}px;
                border-radius: {ICON_SIZE/2}px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG["Controls"]["hover-color"]};
                border-color: {CONFIG["Controls"]["hover-color"]}
            }}
            """
        self.play = QPushButton('', self)
        self.play.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/play.png'))
        self.play.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.play.setStyleSheet(BUTTON_STYLE)
        self.play.clicked.connect(self.run_command)
        layout.addWidget(self.play)

        # code line
        self.line = QLineEdit(self)
        self.line.setText(self._text)
        #self.line.setPlaceholderText(self._text)
        self.line.setStyleSheet(f'''
            QLineEdit {{
                font:{CONFIG['CodeLine']['font']};
                color:{CONFIG['CodeLine']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                width: 100px;
                height: 25px;
            }}   

            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border: 1px solid {CONFIG['CodeLine']['focus']['border-color']};
            }} 
            ''')

        self.line.returnPressed.connect(self.run_command)

        layout.addWidget(self.line)
        self.setLayout(layout)
        self._current_args = self.get_current_parameters(self.line.text())
        #print(f"self._current_args = {self._current_args}") # monitor
    
    def set_text(self,text):
        self.line.setText(text)
        self._text =text
    def run_command(self):
        def set_marks_to_text(text):
            if not text.startswith('>> '):
                text = '>> ' + text
            return text
        def get_args(text):
            def get_splits(text):
                pattern = r',(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)'
                return re.split(pattern, text)

            try:
                args_string = text[text.find('(')+1:text.find(')')]
                splitted_args = get_splits(args_string)
                print(splitted_args)
                return {item.split('=')[0]:item.split('=')[1] for item in splitted_args}
            except Exception as e:
                return e     
        
        #print(f"code line run Command: {set_marks_to_text(self.line.text())[3:]}") # monitor
        self.line.setText(set_marks_to_text(self.line.text()))     
        current_cmd_block = self.parent().parent()
        current_cmd_block._cmd = set_marks_to_text(self.line.text())[3:] # update new cmd
        current_cmd_block._args = get_args(current_cmd_block._cmd) # get cmd args
        current_cmd_block._output = 'my output'
        current_cmd_block.run_command()    
    def get_current_parameters(self,text): 
        cmd_string = text[text.find('(')+1:text.rfind(')')]
        matches = re.findall(r"(\w+)\s*=\s*(\[.*?\]|\(.*?\)|\{.*?\}|'.*?'|\".*?\"|[^,)]+)",cmd_string)   
    
        return {item[0].strip():item[1].strip() for item in matches}

class CodeControls(QWidget):
    def __init__(self):
        super().__init__()
        self.setObjectName("CodeControls")
        ICON_SIZE = 15

        layout = QHBoxLayout()

        BUTTON_STYLE = f"""
            QPushButton {{
                background-color: {CONFIG["Controls"]["background-color"]}; 
                padding: {ICON_SIZE/10}px;
                width: {ICON_SIZE}px;
                height: {ICON_SIZE}px;
                border-radius: {ICON_SIZE/2}px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG["Controls"]["hover-color"]};
                border-color: {CONFIG["Controls"]["hover-color"]}
            }}
            """
        
        self.up = QPushButton('', self)
        self.up.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/up.png'))
        self.up.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.up.setStyleSheet(BUTTON_STYLE)
        self.up.clicked.connect(self.set_up)
        layout.addWidget(self.up)

        self.down = QPushButton('', self)
        self.down.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/down.png'))
        self.down.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.down.setStyleSheet(BUTTON_STYLE)
        self.down.clicked.connect(self.set_down)
        layout.addWidget(self.down)

        self.pin = QPushButton('', self)
        self.pin.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/pin.png'))
        self.pin.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.pin.setStyleSheet(BUTTON_STYLE)
        self.pin.clicked.connect(self.set_pin)
        layout.addWidget(self.pin)

        self.add = QPushButton('', self)
        self.add.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/add.png'))
        self.add.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.add.setStyleSheet(BUTTON_STYLE)
        self.add.clicked.connect(self.set_add)
        layout.addWidget(self.add)

        self.trash = QPushButton('', self)
        self.trash.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/trash.png'))
        self.trash.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.trash.setStyleSheet(BUTTON_STYLE)
        self.trash.clicked.connect(self.set_delete)
        layout.addWidget(self.trash)

        self.save = QPushButton('', self)
        self.save.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/save.png'))
        self.save.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.save.setStyleSheet(BUTTON_STYLE)
        self.save.clicked.connect(self.set_save)
        layout.addWidget(self.save)

        self.setLayout(layout)

    def set_pin(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        layout.removeWidget(current_cmd_block)
        layout.insertWidget(0,current_cmd_block)
    def set_up(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        if current_index > 0:
            layout.removeWidget(current_cmd_block)
            layout.insertWidget(current_index - 1, current_cmd_block)
    def set_down(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        if current_index < layout.count() - 1:
            layout.removeWidget(current_cmd_block)
            layout.insertWidget(current_index + 1, current_cmd_block)
    def set_add(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        layout.insertWidget(current_index + 1, CommandBlock(cmd=current_cmd_block._cmd))        
    def set_delete(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        layout.removeWidget(current_cmd_block)
        current_cmd_block.deleteLater()
    def set_save(self): 
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        data_viewer = DATA_TABLE.get('data_viewer')
        if data_viewer:
            data_viewer.story_container.addWidget(current_cmd_block)
        layout.update()
              
class OutputControls(QWidget):
    def __init__(self):
        super().__init__()
        self.setObjectName("OutputControls")
        ICON_SIZE = 20

        layout = QHBoxLayout()
        layout.setAlignment(Qt.AlignLeft)  # Align buttons to the left

        BUTTON_STYLE = f"""
            QPushButton {{
                background-color: {CONFIG["Controls"]["background-color"]}; 
                padding: {ICON_SIZE/4}px;
                width: {ICON_SIZE}px;
                height: {ICON_SIZE}px;
                border-radius: {ICON_SIZE/2}px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG["Controls"]["hover-color"]};
                border-color: {CONFIG["Controls"]["hover-color"]}
            }}
            """
        
        self.pic = QPushButton('', self)
        self.pic.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/pic.png'))
        self.pic.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.pic.setStyleSheet(BUTTON_STYLE)
        self.pic.clicked.connect(self.set_picture)
        layout.addWidget(self.pic)

        self.comment = QPushButton('', self)
        self.comment.setIcon(QIcon(f'{CURRENT_PATH}/icons/command_block/{ICON_STYLE_CB}/comment.png'))
        self.comment.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
        self.comment.setStyleSheet(BUTTON_STYLE)
        self.comment.clicked.connect(self.set_comment)
        layout.addWidget(self.comment)

        self.setLayout(layout)

    def set_comment(self):
        #print('comment') # monitor
        current_cmd_block = self.parent().parent()
        current_cmd_block.add_comment()
    def set_pin(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        layout.removeWidget(current_cmd_block)
        layout.insertWidget(0,current_cmd_block)
    def set_up(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        if current_index > 0:
            layout.removeWidget(current_cmd_block)
            layout.insertWidget(current_index - 1, current_cmd_block)
    def set_down(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        if current_index < layout.count() - 1:
            layout.removeWidget(current_cmd_block)
            layout.insertWidget(current_index + 1, current_cmd_block)
    def set_add(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        layout.insertWidget(current_index + 1, CommandBlock(cmd=current_cmd_block._cmd))        
    def set_delete(self):
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        current_index = layout.indexOf(current_cmd_block)
        layout.removeWidget(current_cmd_block)
        current_cmd_block.deleteLater()
    def set_save(self): 
        current_cmd_block = self.parent().parent()
        layout = current_cmd_block.parent().layout()
        data_viewer = DATA_TABLE.get('data_viewer')
        if data_viewer:
            data_viewer.story_container.addWidget(current_cmd_block)
        layout.update()
    def set_fold(self):     
        def is_folded(cmd_block):
            return len(cmd_block._folded_items) > 0

        #print("Folding") 
        current_cmd_block = self.parent().parent()   
        items = current_cmd_block.children()[0].children()

        if current_cmd_block._output != None:
            if is_folded(cmd_block=current_cmd_block):
                current_cmd_block._output.show()
                current_cmd_block._folded_items = []
                current_cmd_block.block.setFixedHeight(150 + current_cmd_block._output._height)
            else:
                current_cmd_block._output.hide()
                current_cmd_block._folded_items.append(current_cmd_block._output)
                current_cmd_block.block.setFixedHeight(170)
                #current_cmd_block.layout.addWidget(TextOutput(text='>>>'))                  
    def set_picture(self):
        output_item = self.parent().parent()._output 
        pixmap = QPixmap(output_item.size())
        output_item.render(pixmap)
        QApplication.clipboard().setPixmap(pixmap)

class ArgsMenu(QWidget):
    def __init__(self,args:dict,cmd_block=None):
        super().__init__()
        self.setObjectName("ArgsMenu")

        self._args = {}
        self._cmd_block = cmd_block
        MAX_ARG_WIDTH = 220
        LABEL_STYLE = f"""
                            QLabel {{
                                font: {CONFIG['CodeLine']['font']};
                                color: {CONFIG['CodeLine']['color']};
                                padding: 0px 0px;
                                border: none;
                            }}
                            """

        self.form_layout = QFormLayout()
        self.form_layout.setLabelAlignment(Qt.AlignRight)     # Align labels
        self.form_layout.setFormAlignment(Qt.AlignTop)  
        self.form_layout.setContentsMargins(40,0,40,0)

        dt_label = QLabel('data table = ')
        dt_label.setStyleSheet(LABEL_STYLE)
        dt_arg_label = QLabel(f"{DATA_TABLE['tables'][DATA_TABLE['current_table_index']]._file_name}")
        dt_arg_label.setStyleSheet(LABEL_STYLE)
        self.form_layout.addRow(dt_label, dt_arg_label)

        for arg_name,arg in args.items():
            arg_label = QLabel(arg_name + ' =')
            arg_label.setStyleSheet(LABEL_STYLE)

            if arg['type'] == 'category':
                combo = QComboBox()
                combo.setStyleSheet(
                    "QComboBox { "
                    f"font: {CONFIG['arguments']['font']}; "
                    "color: purple;"
                    "padding: 1px 1px; "
                    "border: 1px solid #dedede; "
                    "border-radius: 5px; "
                    f"background-color: #f9f0fa; "
                    "selection-background-color: #dedede; "
                    "}"
                    "QComboBox::down-arrow {"
                        "border: none;" 
                        "background: none;" 
                    "}"
                    "QComboBox::drop-down {"
                        "border: none;" 
                    "}"
                    )
                combo.addItems(arg['options'])
                #print(f"arg_name = {arg_name}, chosen = {self.get_parameter_value(arg_name)} all options = {arg['options']}") # monitor
                combo.setCurrentText(f"'{str(self.get_parameter_value(arg_name))}'")  # Set default text
                combo.setFixedWidth(min(MAX_ARG_WIDTH,20 + max([12*len(str(item)) for item in arg['options']])))
                combo.currentIndexChanged.connect(self.update_command)
                self.form_layout.addRow(arg_label,combo)
            elif arg['type'] in ['integer','float']:
                int_arg = QLineEdit()
                int_arg.setValidator(QDoubleValidator() if arg['type'] == 'float' else QIntValidator())
                int_arg.setText(str(self.get_parameter_value(arg_name)))  # Set default text
                int_arg.setFixedWidth(min(MAX_ARG_WIDTH,max([12*len(str(item)) for item in arg['options']])))
                int_arg.setStyleSheet(
                    "QLineEdit { "
                    f"font: {CONFIG['arguments']['font']}; "
                    "color: green;"
                    "padding: 1px 1px; "
                    "border: 1px solid #dedede; "
                    "border-radius: 5px; "
                    f"background-color: #f0faf7; "
                    "selection-background-color: #eafaf1; "
                    "}"
                    )
                int_arg.textChanged.connect(self.update_command)                    
                self.form_layout.addRow(arg_label,int_arg)    
            elif arg['type'] == 'text':
                text_arg = QLineEdit()
                text_arg.setText(f"'{str(self.get_parameter_value(arg_name))}'".replace("''","'"))  # Set default text
                text_arg.setFixedWidth(150)
                text_arg.setStyleSheet(
                                        "QLineEdit { "
                                        f"font: {CONFIG['arguments']['font']}; "
                                        "color: blue;"
                                        "padding: 1px 1px; "
                                        "border: 1px solid #dedede; "
                                        "border-radius: 5px; "
                                        f"background-color: #edfbfc; "
                                        "selection-background-color: #eafaf1; "
                                        "}"
                                    )
                text_arg.textChanged.connect(self.update_command)  
                self.form_layout.addRow(arg_label,text_arg)  
            elif arg['type'] == 'query':
                self.sql_arg = QTextEdit()
                self.sql_arg.setStyleSheet(f"""
                                        QTextEdit {{
                                                font:{CONFIG['CodeLine']['font']};
                                                color:{CONFIG['CodeLine']['color']};
                                                border: {CONFIG['CodeLine']['border']};
                                                background-color: {CONFIG['CodeLine']['background-color']};
                                                border-radius: 5px;
                                                padding: 15px;
                                            }}
                                            QTextEdit:focus {{
                                                border: 2px solid #3498db;
                                                background-color: white;
                                            }}
                                        """)
                self.sql_arg.setHtml(str(self.get_parameter_value(arg_name)[1:-1]))    
                self.sql_arg.textChanged.connect(self.set_sql)  
                self.form_layout.addRow(arg_label,self.sql_arg)
            elif arg['type'] == 'items':
                self.item_list = QListWidget()
                self.item_list.setSelectionMode(QAbstractItemView.MultiSelection)
                self.item_list.setStyleSheet(
                    f"""
                    QListWidget {{
                        background-color: None;
                        border: None;
                        padding: 3px;
                        font: {CONFIG['CodeLine']['font']};
                    }}

                    """
                    )
                self.item_list.setFlow(QListWidget.LeftToRight)
                self.item_list.setWrapping(True)  # Allow wrapping if width is exceeded

                checked_items = self.get_parameter_value(arg_name)
                for text_item in arg['options']:
                    item = QListWidgetItem(text_item)
                    item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
                    if text_item in checked_items:
                        item.setCheckState(Qt.Checked)
                    else:
                        item.setCheckState(Qt.Unchecked)
                    self.item_list.addItem(item)

                self.item_list.itemChanged.connect(self.update_command)
                self.form_layout.addRow(arg_label,self.item_list)    

        self.setLayout(self.form_layout)

    def get_parameter_value(self,arg_name: str):
        """
        Extracts the value of a parameter from a Python-like function call string.
        Returns the value as a Python object when possible, else as raw string.
        """
        # Regex: match arg_name=value (value can be quoted, bracketed, or bare)
        cmd_string = self._cmd_block._cmd
        pattern = rf"{arg_name}\s*=\s*(\[.*?\]|\(.*?\)|\{{.*?\}}|'.*?'|\".*?\"|[^,)\s]+)"
        match = re.search(pattern, cmd_string)
        if not match:
            return None  # arg not found

        raw_value = match.group(1).strip()

        try:
            # Safely convert to Python literal (str, int, float, bool, list, dict, tuple, None)
            return ast.literal_eval(raw_value)
        except Exception:
            # If not evaluable (e.g., variable name), return raw string
            return raw_value    
    def set_sql(self):
        # print(self.sql_arg.toPlainText()) # monitor
        query_string = '"' + self.sql_arg.toPlainText().replace('\n',' ').replace('"', "'") + '"'
        cmd = self._cmd_block.code_line._text
        query_end_index = min([cmd.find(c,cmd.find('query=') + len('query=') + 1) for c in [')','"',"'"]])
        old_query = cmd[cmd.find('query=') + len('query='):query_end_index]
        #self._cmd_block.code_line.set_text(f"old_query = {old_query} >> new query = {query_string}") # monitor
        self._cmd_block.code_line.set_text(cmd.replace(old_query,query_string))
    def update_command(self):      
        def set_new_parameters_to_cmd(cmd:str,args:ArgsMenu) -> str:
            def delete_func_parameters(cmd:str): 
                open_idx = cmd.find('(')
                close_idx = cmd.rfind(')')
                if open_idx == -1 or close_idx == -1:
                    return cmd
                prefix = cmd[:open_idx + 1]
                suffix = cmd[close_idx:]
                params = cmd[open_idx + 1:close_idx]

                new_params = []
                delete_flag = False
                bracket_depth = 0
                for char in params:
                    if char in ['[', '(', '{']:
                        bracket_depth += 1
                    elif char in [']', ')', '}']:
                        if bracket_depth > 0:
                            bracket_depth -= 1
                            continue
                    if bracket_depth > 0 and delete_flag:
                        continue
                    if char == '=' and bracket_depth == 0:
                        delete_flag = True
                        new_params.append(char)
                        continue
                    elif char == ',' and bracket_depth == 0:
                        delete_flag = False
                        new_params.append(char)
                        continue
                    if delete_flag:
                        continue
                    new_params.append(char)

                return prefix + ''.join(new_params) + suffix
            def get_new_parameters(args:ArgsMenu):
                """Get widget values, safely serialized for command injection."""
                param = []
                for widget in args.children():
                    if isinstance(widget, QComboBox):
                        val = widget.currentText()
                    elif isinstance(widget, QLineEdit):
                        val = widget.text()
                    elif isinstance(widget, QTextEdit):
                        val = widget.toPlainText()
                    elif isinstance(widget, QListWidget):
                        val = [widget.item(i).text() for i in range(widget.count()) if widget.item(i).checkState() == Qt.Checked]
                    else:
                        continue

                    # Serialize lists, tuples, dicts, numbers, bools, None
                    if isinstance(val, (list, tuple, dict)):
                        param.append(repr(val))
                    else:
                        # Keep normal strings as-is (no extra quotes)
                        param.append(val if val != '' else None)

                return param
            
            cmd_string = delete_func_parameters(cmd)
            values = get_new_parameters(args)

            for val in values:
                if val is None:
                    continue  # skip empty values
                cmd_string = cmd_string.replace('=', f"@{val}", 1)

            return cmd_string.replace('@', '=')  

        #print('update command') # monitor
        # set code line
        code_line = self.parent().findChild(CodeLine)
        code_line.set_text(set_new_parameters_to_cmd(cmd=code_line._text,args=self))
        code_line._current_args = code_line.get_current_parameters(code_line.line.text())

        # set arguments fields
        #print(self.children()[1:])
        for item,current_arg in zip(self.children()[1:],code_line._current_args.values()):
            #print(f"item={item}, current_arg={current_arg}") # monitor
            if isinstance(item,QComboBox):
                item.setCurrentText(current_arg)
            elif isinstance(item,QLineEdit):
                item.setText(current_arg)    
            elif isinstance(item,QTextEdit):
                item.setHtml(current_arg)      
class Comment(QWidget):
    def __init__(self, expanded_height=120, duration=500):
        super().__init__()

        self._ROW_HEIGHT = 30
        self._EXPANDED_HEIGHT = expanded_height
        self._placeholder_cleared = False

        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(2)

        TOOLBAR_BTN = f"""
            QPushButton {{
                background: transparent;
                border: none;
                font: 12px "Consolas";
                padding: 2px 8px;
                border-radius: 4px;
                min-width: 24px;
            }}
            QPushButton:hover {{
                background: {CONFIG['Controls']['hover-color']};
            }}
            QPushButton:checked {{
                background: {CONFIG['CodeLine']['border'].split(' ')[-1]};
            }}
        """

        self.toolbar = QWidget()
        self.toolbar.setFixedHeight(28)
        tb_layout = QHBoxLayout(self.toolbar)
        tb_layout.setContentsMargins(4, 0, 4, 0)
        tb_layout.setSpacing(2)

        self.btn_red = QPushButton("A")
        self.btn_red.setStyleSheet(TOOLBAR_BTN + "QPushButton { color: #d32f2f; font-weight: bold; }")
        self.btn_red.clicked.connect(lambda: self._set_color(QColor("#d32f2f")))
        tb_layout.addWidget(self.btn_red)

        self.btn_green = QPushButton("A")
        self.btn_green.setStyleSheet(TOOLBAR_BTN + "QPushButton { color: #2e7d32; font-weight: bold; }")
        self.btn_green.clicked.connect(lambda: self._set_color(QColor("#2e7d32")))
        tb_layout.addWidget(self.btn_green)

        self.btn_black = QPushButton("A")
        self.btn_black.setStyleSheet(TOOLBAR_BTN + "QPushButton { color: #000000; font-weight: bold; }")
        self.btn_black.clicked.connect(lambda: self._set_color(QColor("#000000")))
        tb_layout.addWidget(self.btn_black)

        tb_layout.addStretch()
        self.toolbar.hide()

        main_layout.addWidget(self.toolbar)

        self.text_box = QTextEdit()
        self.text_box.setStyleSheet(f"""
            QTextEdit {{
                font: {CONFIG['CodeLine']['font']};
                color: black;
                border: {CONFIG['CodeLine']['border']};
                background-color: {CONFIG['CodeLine']['background-color']};
                border-radius: {CONFIG['CodeLine']['border-radius']};
                padding: 5px;
            }}
            QTextEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border: 1px solid {CONFIG['CodeLine']['focus']['border-color']};
            }}
        """)
        self.text_box.setHtml("<p>Type Comment.</p>")
        self.text_box.setFixedHeight(self._EXPANDED_HEIGHT)
        self.text_box.installEventFilter(self)

        main_layout.addWidget(self.text_box)

    def _set_color(self, color):
        fmt = QTextCharFormat()
        fmt.setForeground(color)
        self._apply_format(fmt)

    def _apply_format(self, fmt):
        cursor = self.text_box.textCursor()
        if cursor.hasSelection():
            cursor.mergeCharFormat(fmt)
        else:
            self.text_box.mergeCurrentCharFormat(fmt)
        self.text_box.setFocus()

    def showEvent(self, event):
        super().showEvent(event)
        self.expand_editor()
    def eventFilter(self, obj, event):
        if obj == self.text_box:
            if event.type() == QEvent.KeyPress and event.key() == Qt.Key_Escape:
                self.collapse_editor()
                return True
            elif event.type() in (QEvent.FocusIn, QEvent.MouseButtonPress):
                self.expand_editor()
        return super().eventFilter(obj, event)
    def collapse_editor(self):
        self.text_box.setReadOnly(True)
        self.text_box.setFixedHeight(self._ROW_HEIGHT)
        self.text_box.setStyleSheet(f"""
            QTextEdit {{
                font: {CONFIG['CodeLine']['font']};
                color: black;
                border: none;
                background-color: transparent;
                padding: 5px;
            }}
        """)
        palette = self.text_box.palette()
        palette.setColor(palette.Base, QColor(0, 0, 0, 0))
        self.text_box.setPalette(palette)
        self.text_box.viewport().setAutoFillBackground(False)
        self.text_box.clearFocus()
        self.toolbar.hide()
    def expand_editor(self):
        self.text_box.setReadOnly(False)
        self.text_box.setFixedHeight(self._EXPANDED_HEIGHT)
        self.text_box.viewport().setAutoFillBackground(True)
        self.text_box.setStyleSheet(f"""
            QTextEdit {{
                font: {CONFIG['CodeLine']['font']};
                color: black;
                border: {CONFIG['CodeLine']['border']};
                background-color: {CONFIG['CodeLine']['background-color']};
                border-radius: {CONFIG['CodeLine']['border-radius']};
                padding: 5px;
            }}
            QTextEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border: 1px solid {CONFIG['CodeLine']['focus']['border-color']};
            }}
        """)
        if not self._placeholder_cleared:
            self.text_box.clear()
            self._placeholder_cleared = True
        self.text_box.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
        self.toolbar.show()
        cursor = self.text_box.textCursor()
        cursor.movePosition(QTextCursor.End)
        self.text_box.setTextCursor(cursor)
        

# advanced widgets
class StoryDropTabBar(QTabBar):
    """Tab bar that accepts dropping a CommandBlock onto the Story tab to move it there (same as Save)."""
    def __init__(self, tab_widget, story_tab_index, story_container, parent=None):
        super().__init__(parent)
        self._tab_widget = tab_widget
        self._story_tab_index = story_tab_index
        self._story_container = story_container
        self.setAcceptDrops(True)

    def dragEnterEvent(self, event):
        if event.mimeData().hasFormat('application/x-commandblock') and isinstance(event.source(), CommandBlock):
            event.acceptProposedAction()

    def dragMoveEvent(self, event):
        if event.mimeData().hasFormat('application/x-commandblock') and isinstance(event.source(), CommandBlock):
            event.acceptProposedAction()

    def dropEvent(self, event):
        if not event.mimeData().hasFormat('application/x-commandblock'):
            return
        source = event.source()
        if not isinstance(source, CommandBlock):
            return
        idx = self.tabAt(event.pos())
        if idx != self._story_tab_index:
            return
        event.acceptProposedAction()
        # Move block to Story (same as Save button)
        old_parent = source.parent()
        if old_parent and hasattr(old_parent, 'layout') and old_parent.layout():
            layout = old_parent.layout()
            if hasattr(layout, 'indexOf') and layout.indexOf(source) >= 0:
                layout.removeWidget(source)
        self._story_container.addWidget(source)
        self._tab_widget.setCurrentIndex(self._story_tab_index)


class CommandBlockContainer(QWidget):
    def __init__(self):
        super().__init__()
        self.setAcceptDrops(True)
        self.setStyleSheet("CommandBlockContainer { background-color: #f9f9f9; }")
        self.setObjectName("CommandBlockContainer")
        self._layout = QVBoxLayout(self)
        self._layout.setAlignment(Qt.AlignTop)
        self._layout.setSpacing(0)

        self._drop_line = QFrame(self)
        self._drop_line.setFixedHeight(3)
        self._drop_line.setStyleSheet("background-color: #3498db; border-radius: 1px;")
        self._drop_line.hide()

    def addWidget(self, widget):
        self._layout.addWidget(widget)

    def _get_drop_index(self, pos):
        for i in range(self._layout.count()):
            widget = self._layout.itemAt(i).widget()
            if widget and pos.y() < widget.geometry().center().y():
                return i
        return self._layout.count()

    def dragEnterEvent(self, event):
        if isinstance(event.source(), CommandBlock):
            event.acceptProposedAction()

    def dragMoveEvent(self, event):
        if isinstance(event.source(), CommandBlock):
            event.acceptProposedAction()
            idx = self._get_drop_index(event.pos())
            if idx < self._layout.count():
                widget = self._layout.itemAt(idx).widget()
                y = widget.geometry().top() - 2
            elif self._layout.count() > 0:
                widget = self._layout.itemAt(self._layout.count() - 1).widget()
                y = widget.geometry().bottom() + 1
            else:
                self._drop_line.hide()
                return
            self._drop_line.setGeometry(4, y, self.width() - 8, 3)
            self._drop_line.show()
            self._drop_line.raise_()

    def dragLeaveEvent(self, event):
        self._drop_line.hide()

    def dropEvent(self, event):
        self._drop_line.hide()
        source = event.source()
        if isinstance(source, CommandBlock):
            target_index = self._get_drop_index(event.pos())
            self._layout.removeWidget(source)
            self._layout.insertWidget(target_index, source)
            event.acceptProposedAction()

class CommandBlock(QWidget):
    def __init__(self, dt: DataTable = pd.DataFrame(), cmd: str = ''):
        super().__init__()
        self.setObjectName("CommandBlock")
        
        self._dt = dt
        self._cmd = cmd
        self._args = None
        self._output = None
        self._folded_items = []

        # --- Main layout for the *entire* CommandBlock widget ---
        # This layout will hold the white frame.
        # We pass 'self' to set this as the main layout for CommandBlock
        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)

        container_layout = QVBoxLayout(self)
        container_layout.setContentsMargins(6, 4, 6, 4)
        container_layout.setSpacing(0)

        self.block = QFrame()
        self.block.setFrameShape(QFrame.NoFrame)
        self.block.setObjectName("CommandBlock_Frame")
        self.block.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
        self.block.setStyleSheet(f"""
            QFrame#CommandBlock_Frame {{
                background-color: white;
                border: 1px solid #e8e8e8;
                border-radius: 8px;
            }}
            """)

        shadow = QGraphicsDropShadowEffect(self)
        shadow.setBlurRadius(10)
        shadow.setOffset(0, 2)
        shadow.setColor(QColor(0, 0, 0, 40))
        self.block.setGraphicsEffect(shadow)

        self.layout = QVBoxLayout()
        self.layout.setContentsMargins(8, 6, 8, 6)
        self.layout.setSpacing(4)
        self.code_layout = QHBoxLayout()
        self._code_line = CodeLine(text=self._cmd)
        self.code_layout.addWidget(self._code_line)
        self.code_layout.addWidget(CodeControls())

        self.layout.addLayout(self.code_layout)

        self.block.setLayout(self.layout)
        container_layout.addWidget(self.block)
    
    def get_attributes(self):
        return {'self._cmd':f"{self._cmd}",'self._args':f"{self._args}",'self._output':f"{self._output}"} 
    def add_comment(self):
        self.comment = Comment()
        self.layout.addWidget(self.comment)
    def run_command(self):
        def delete_prev_output(self):
            for item_type in [ArgsMenu, TextOutput, TableOutput, AnalysisOutput, PlotOutput, OutputControls]:
                try:
                    output_widget = self.findChild(item_type)
                    output_widget.setParent(None)
                    output_widget.deleteLater()
                except:
                    pass            
            
        delete_prev_output(self)

        try:
            # no threads run
            local_vars = {'df': self._dt._df, 'dt': self._dt}
            local_vars.update({k: getattr(func, k) for k in dir(func) if not k.startswith("_")})
            output_obj = eval(self._cmd, {}, local_vars) 

            self._args = ArgsMenu(args=output_obj['args'], cmd_block=self)
            self.layout.addWidget(self._args)

            self.output_controls = OutputControls() ##
            self.layout.addWidget(self.output_controls) ##

            if output_obj['output_type'] == 'text':
                self._output = TextOutput(output_obj['output'])
            elif output_obj['output_type'] == 'table':
                self._output = TableOutput(output_obj['output'])
            elif output_obj['output_type'] == 'plot':  
                self._output = PlotOutput(fig=output_obj['output'])      
            elif output_obj['output_type'] == 'analysis':  
                self._output = AnalysisOutput(
                    plot=output_obj['output']['plot'],
                    log=output_obj['output']['log'],
                    table=output_obj['output']['table']
                    )  
                       
        except Exception:
            #pass # use for full exception in vscode
            error = traceback.format_exc()   
            self._output = TextOutput(text=error)  

        self.layout.addWidget(self._output)

    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self._drag_start_pos = event.pos()
        super().mousePressEvent(event)

    def mouseMoveEvent(self, event):
        if not (event.buttons() & Qt.LeftButton) or not hasattr(self, '_drag_start_pos'):
            return super().mouseMoveEvent(event)
        if (event.pos() - self._drag_start_pos).manhattanLength() < QApplication.startDragDistance():
            return super().mouseMoveEvent(event)

        drag = QDrag(self)
        mime = QMimeData()
        mime.setData('application/x-commandblock', b'')
        drag.setMimeData(mime)

        pixmap = self.grab()
        scaled = pixmap.scaledToWidth(min(pixmap.width(), 400), Qt.SmoothTransformation)
        painter = QPainter(scaled)
        painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
        painter.fillRect(scaled.rect(), QColor(0, 0, 0, 140))
        painter.end()
        drag.setPixmap(scaled)
        drag.setHotSpot(event.pos())
        drag.exec_(Qt.MoveAction)
    
# data viewer
class DataViewer(QWidget):
    def __init__(self):
        super().__init__()
        self.setObjectName("DataViewer")

        layout = QVBoxLayout()
        
        
        # Create tab widget
        self.tabs = QTabWidget()
        self.tabs.tabBar().setExpanding(False)

        tabs_shadow = QGraphicsDropShadowEffect(self)
        tabs_shadow.setBlurRadius(20)
        tabs_shadow.setOffset(0, 4)
        tabs_shadow.setColor(QColor(0, 0, 0, 40))
        self.tabs.setGraphicsEffect(tabs_shadow)

        self.tabs.setStyleSheet(f"""
            QTabWidget::pane {{
                border: none;
                background: #f5f5f5;
                border-radius: 8px;
            }}
            QTabBar {{
                background: transparent;
                border: none;
                padding: 4px 4px 0px 4px;
                alignment: left;
            }}
            QTabBar::tab {{
                background: transparent;
                padding: 8px 16px;
                margin: 0px 2px;
                font: 13px -apple-system, "SF Pro Text", "Helvetica Neue", sans-serif;
                color: #86868b;
                border: none;
                border-top-left-radius: 8px;
                border-top-right-radius: 8px;
                min-width: 60px;
            }}
            QTabBar::tab:selected {{
                background: #f5f5f5;
                color: #1d1d1f;
                font: bold 13px -apple-system, "SF Pro Text", "Helvetica Neue", sans-serif;
            }}
            QTabBar::tab:hover:!selected {{
                background: rgba(0, 0, 0, 0.04);
                color: #1d1d1f;
            }}
            QScrollArea {{
                border: none;
                background: #f9f9f9;
            }}
            QScrollBar:vertical {{
                border: none;
                background: transparent;
                width: 8px;
                margin: 2px 1px;
            }}
            QScrollBar::handle:vertical {{
                background: #dadce0;
                min-height: 40px;
                border-radius: 4px;
            }}
            QScrollBar::handle:vertical:hover {{
                background: #bdc1c6;
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                background: none;
                height: 0px;
            }}
            """)
        DATA_COMBO_STYLE = f"""
                QComboBox {{
                    font: {CONFIG['arguments']['font']};
                    color: #3498db;
                    padding: 1px 1px;
                    border: 1px solid #3498db;
                    border-radius: 5px;
                    background-color: #f4fbff ;
                    selection-background-color: #dedede;
                }}
                QComboBox::down-arrow {{
                    border: none;
                    background: none;
                }}
                QComboBox::drop-down {{
                    border: none;
                }}
            """
        self.tabs.setMinimumWidth(400)
        
        # Story tab content (created early so custom tab bar can use it)
        self.story_scroll = QScrollArea()
        self.story_scroll.setWidgetResizable(True)
        self.story_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
        self.story_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.story_container = CommandBlockContainer()
        self.story_scroll.setWidget(self.story_container)
        # Custom tab bar must be set before addTab so tabs are added to this bar
        self._story_drop_tab_bar = StoryDropTabBar(self.tabs, -1, self.story_container)
        self.tabs.setTabBar(self._story_drop_tab_bar)
        # #region agent log
        _bar2 = self.tabs.tabBar()
        try:
            with open("/Users/sagico/Documents/Rapyd/.cursor/debug-0e31d1.log", "a") as _f:
                _f.write(json.dumps({"sessionId":"0e31d1","hypothesisId":"H2","location":"widgets.py:after_setTabBar","message":"icon size after setTabBar before setIconSize","data":{"tabs_icon_w":self.tabs.iconSize().width(),"tabs_icon_h":self.tabs.iconSize().height(),"bar_icon_w":_bar2.iconSize().width(),"bar_icon_h":_bar2.iconSize().height()},"timestamp":int(time.time()*1000)}) + "\n")
        except Exception:
            pass
        # #endregion
        self.tabs.setIconSize(QSize(45, 45))
        # #region agent log
        try:
            with open("/Users/sagico/Documents/Rapyd/.cursor/debug-0e31d1.log", "a") as _f:
                _f.write(json.dumps({"sessionId":"0e31d1","hypothesisId":"H3","location":"widgets.py:after_setIconSize_30","message":"icon size after setIconSize(30,30)","data":{"tabs_icon_w":self.tabs.iconSize().width(),"tabs_icon_h":self.tabs.iconSize().height(),"bar_icon_w":self.tabs.tabBar().iconSize().width(),"bar_icon_h":self.tabs.tabBar().iconSize().height()},"timestamp":int(time.time()*1000)}) + "\n")
        except Exception:
            pass
        # #endregion
        
        # Preview
        self.preview_main = QWidget()
        self.preview_main_layout = QVBoxLayout()
        self.preview_main_layout.setAlignment(Qt.AlignTop)
        self.preview_main_layout.setSpacing(1)
        self.preview_main.setLayout(self.preview_main_layout)
        self.tabs.addTab(self.preview_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/preview.png'), "Preview")
        self.preview_comb = QComboBox()
        self.preview_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.preview_comb.currentIndexChanged.connect(self.switch_preview_layout)
        self.preview_main_layout.addWidget(self.preview_comb)
        self.preview_stack = QWidget()
        self.preview_stack_layout = QStackedLayout()
        self.preview_stack.setLayout(self.preview_stack_layout)
        self.preview_main_layout.addWidget(self.preview_stack)

        # Edit
        self.edit_main = QWidget()
        self.edit_main_layout = QVBoxLayout()
        self.edit_main_layout.setAlignment(Qt.AlignTop)
        self.edit_main_layout.setSpacing(1)
        self.edit_main.setLayout(self.edit_main_layout)
        self.tabs.addTab(self.edit_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/edit.png'), "Edit")
        self.edit_comb = QComboBox()
        self.edit_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.edit_comb.currentIndexChanged.connect(self.switch_edit_layout)
        self.edit_main_layout.addWidget(self.edit_comb)
        self.edit_stack = QWidget()
        self.edit_stack_layout = QStackedLayout()
        self.edit_stack.setLayout(self.edit_stack_layout)
        self.edit_main_layout.addWidget(self.edit_stack)

        # SQL
        self.sql_main = QWidget()
        self.sql_main_layout = QVBoxLayout()
        self.sql_main_layout.setAlignment(Qt.AlignTop)
        self.sql_main_layout.setSpacing(1)
        self.sql_main.setLayout(self.sql_main_layout)
        self.tabs.addTab(self.sql_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/sql.png'), "SQL")
        self.sql_comb = QComboBox()
        self.sql_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.sql_comb.currentIndexChanged.connect(self.switch_sql_layout)
        self.sql_main_layout.addWidget(self.sql_comb)
        self.sql_stack = QWidget()
        self.sql_stack_layout = QStackedLayout()
        self.sql_stack.setLayout(self.sql_stack_layout)
        self.sql_main_layout.addWidget(self.sql_stack)

        # Plots
        self.plots_main = QWidget()
        self.plots_main_layout = QVBoxLayout()
        self.plots_main_layout.setAlignment(Qt.AlignTop)
        self.plots_main_layout.setSpacing(1)
        self.plots_main.setLayout(self.plots_main_layout)
        self.tabs.addTab(self.plots_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/plots.png'), "Plots")
        self.plots_comb = QComboBox()
        self.plots_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.plots_comb.currentIndexChanged.connect(self.switch_plots_layout)
        self.plots_main_layout.addWidget(self.plots_comb)
        self.plots_stack = QWidget()
        self.plots_stack_layout = QStackedLayout()
        self.plots_stack.setLayout(self.plots_stack_layout)
        self.plots_main_layout.addWidget(self.plots_stack)

        # Analysis
        self.analysis_main = QWidget()
        self.analysis_main_layout = QVBoxLayout()
        self.analysis_main_layout.setAlignment(Qt.AlignTop)
        self.analysis_main_layout.setSpacing(1)
        self.analysis_main.setLayout(self.analysis_main_layout)
        self.tabs.addTab(self.analysis_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/analysis.png'), "Analysis")
        self.analysis_comb = QComboBox()
        self.analysis_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.analysis_comb.currentIndexChanged.connect(self.switch_analysis_layout)
        self.analysis_main_layout.addWidget(self.analysis_comb)
        self.analysis_stack = QWidget()
        self.analysis_stack_layout = QStackedLayout()
        self.analysis_stack.setLayout(self.analysis_stack_layout)
        self.analysis_main_layout.addWidget(self.analysis_stack)

        # Timeseries Analysis
        self.time_main = QWidget()
        self.time_main_layout = QVBoxLayout()
        self.time_main_layout.setAlignment(Qt.AlignTop)
        self.time_main_layout.setSpacing(1)
        self.time_main.setLayout(self.time_main_layout)
        self.tabs.addTab(self.time_main, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/time.png'), "Time")
        self.time_comb = QComboBox()
        self.time_comb.setStyleSheet(DATA_COMBO_STYLE)
        self.time_comb.currentIndexChanged.connect(self.switch_time_layout)
        self.time_main_layout.addWidget(self.time_comb)
        self.time_stack = QWidget()
        self.time_stack_layout = QStackedLayout()
        self.time_stack.setLayout(self.time_stack_layout)
        self.time_main_layout.addWidget(self.time_stack)

        # Story (content already created above)
        self.tabs.addTab(self.story_scroll, QIcon(f'{CURRENT_PATH}/icons/{ICON_SET}/story.png'), "Story")
        self._story_drop_tab_bar._story_tab_index = self.tabs.count() - 1
        
        layout.addWidget(self.tabs)
        self.setLayout(layout)

    def switch_preview_layout(self, index):
        self.preview_stack_layout.setCurrentIndex(index)
    def switch_edit_layout(self, index):
        self.edit_stack_layout.setCurrentIndex(index)    
    def switch_sql_layout(self, index):
        self.sql_stack_layout.setCurrentIndex(index)     
    def switch_plots_layout(self, index):
        self.plots_stack_layout.setCurrentIndex(index)   
    def switch_analysis_layout(self, index):
        self.analysis_stack_layout.setCurrentIndex(index)   
    def switch_time_layout(self, index):
        self.time_stack_layout.setCurrentIndex(index)         
    def set_preview(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.preview_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['Preview']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.preview_stack_layout.addWidget(scroll_area)
    def set_edit(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.edit_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['Edit']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.edit_stack_layout.addWidget(scroll_area)  
    def set_sql(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.sql_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['SQL']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.sql_stack_layout.addWidget(scroll_area)       
    def set_plots(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.plots_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['Plots']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.plots_stack_layout.addWidget(scroll_area)           
    def set_analysis(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.analysis_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['Analysis']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.analysis_stack_layout.addWidget(scroll_area)            
    def set_time(self):
        current_table = DATA_TABLE['tables'][DATA_TABLE['current_table_index']]
        self.time_comb.addItem(f"DataTable = {current_table._file_name}")

        container = CommandBlockContainer()
        for cmd_string in COMMANDS['Time']:
            container.addWidget(CommandBlock(cmd=cmd_string, dt=current_table))

        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(container)
        self.time_stack_layout.addWidget(scroll_area) 

# file explorer
class FileExplorer(QWidget):
    def __init__(self,file_tree=None):
        super().__init__()

        self._selected_file = None
        self._file_tree = file_tree
        #print(f'file_tree = {file_tree}') # monitor

        layout = QVBoxLayout(self)

        self.path = QLineEdit(self)
        self.path.setStyleSheet(f'''
            QLineEdit {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['CodeLine']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                width: 100px;
                height: 20px;
            }}   

            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }} 
            ''')
        layout.addWidget(self.path)
        #self.line.returnPressed.connect(self.run_command)
        
        self.filename = QLineEdit(self)
        self.filename.setStyleSheet(f'''
            QLineEdit {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['FileExplorer']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                width: 100px;
                height: 20px;
            }}   

            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }} 
            ''')
        layout.addWidget(self.filename)

        self.model = QFileSystemModel()
        self.model.setRootPath(QDir.rootPath())
        self.treeView = QTreeView(self)
        self.treeView.setModel(self.model)
        self.treeView.setRootIndex(self.model.index(QDir.rootPath()))
        self.treeView.setHeaderHidden(True)
        self.treeView.setColumnWidth(0, 600)
        self.treeView.setColumnHidden(3, True) # Hide the "Date Modified" column (index 3)
        self.treeView.setColumnHidden(2, True) # Hide the "type" column (index 2)
        self.treeView.doubleClicked.connect(self.get_file)
        self.setStyleSheet(f"""
            QWidget {{
                color: {CONFIG['FileExplorer']['color']};
                background-color: white;
                border-radius: 5px;
                padding: 2px;
            }}
            QTreeView {{
                border: {CONFIG['CodeLine']['border']};
                background-color: {CONFIG['FileExplorer']['background-color']};
                font: {CONFIG['FileExplorer']['font']};
            }}
            QTreeView::item {{
                padding: 1px;
                border-radius: 0px;
            }}
            QTreeView::item:hover {{
                background-color: #e0e0e0;
            }}
            QTreeView::item:selected {{
                background-color: {CONFIG['FileExplorer']['selection-color']};
                color: white;
            }}

            /* Scrollbar Customization */
            QScrollBar:vertical {{
                border: none;
                background: white; 
                width: 15px; /* Scrollbar width */
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:vertical {{
                background: {CONFIG['Controls']['hover-color']}; 
                min-height: 20px;
                border-radius: 2px;
            }}
            QScrollBar::handle:vertical:hover {{
                background: {CONFIG['CodeLine']['color']}; /* Darker on hover */
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                background: none; /* Hide arrows */
            }}

            /* Horizontal Scrollbar Customization */
            QScrollBar:horizontal {{
                border: none;
                background: white;
                height: 15px; /* Scrollbar height */
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:horizontal {{
                background: {CONFIG['Controls']['hover-color']};
                min-width: 20px;
                border-radius: 2px;
            }}
            QScrollBar::handle:horizontal:hover {{
                background: {CONFIG['CodeLine']['color']}; /* Darker on hover */
            }}
            QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{
                background: none; /* Hide arrows */
            }}
            """)

        layout.addWidget(self.treeView)

    def get_file(self, index: QModelIndex):
        def load_file_to_data_viewer(self):
            data_viewer = DATA_TABLE.get('data_viewer')
            if not data_viewer:
                return
            data_viewer.set_preview()
            data_viewer.set_edit()
            data_viewer.set_sql()
            data_viewer.set_analysis()
            data_viewer.set_plots()
            data_viewer.set_time()

        self._selected_file = self.model.filePath(index) 
        self.path.setText(self._selected_file)
        #print(self._selected_file)       

        file_type = self._selected_file.split('.')[-1] 
        if file_type in ['csv','xlsx','xls']:
            new_table = DataTable(file_tree=DATA_TABLE['file_tree'],path=self._selected_file)
            DATA_TABLE['tables'].append(new_table)
            table_index = len(DATA_TABLE['tables']) - 1
            DATA_TABLE['current_table_index'] = table_index
            print(f'[+] Load DataTable: {new_table}') # monitor
            self.filename.setText(f"DataTable = {new_table._file_name}")
            self._file_tree.add_subfile(parent_file=new_table._file_name,df_name='df')
            self._file_tree.highlight_active(new_table._file_name, 'df')
            load_file_to_data_viewer(self)
class FileTree(QWidget):
    def __init__(self):
        super().__init__()   
        self.setObjectName("FileTree")         

        self._data_item = None       
        layout = QVBoxLayout(self)
        
        self.filename = QLineEdit(self)
        self.filename.setStyleSheet(f'''
            QLineEdit {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['FileExplorer']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                width: 100px;
                height: 20px;
            }}   

            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }} 
            ''')
        layout.addWidget(self.filename)

        # TreeView and Model
        self.tree = QTreeView()
        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
        self.tree.customContextMenuRequested.connect(self.get_file_menu)
        self.model = QStandardItemModel()
        self.tree.setHeaderHidden(True)
        self.root_node = self.model.invisibleRootItem()

        self.tree.setModel(self.model)
        layout.addWidget(self.tree)
        self.setStyleSheet(f"""
            QWidget {{
                color: {CONFIG['FileExplorer']['color']};
                background-color: white;
                border-radius: 5px;
                padding: 2px;
            }}
            QTreeView {{
                background-color: white;
                font: {CONFIG['FileExplorer']['font']};
            }}
            QTreeView::item {{
                padding: 1px;
                border-radius: 0px;
            }}
            QTreeView::item:hover {{
                background-color: #e0e0e0;
            }}
            QTreeView::item:selected {{
                background-color: {CONFIG['FileExplorer']['selection-color']};
                color: white;
            }}

            /* Scrollbar Customization */
            QScrollBar:vertical {{
                border: none;
                background: white; 
                width: 15px; /* Scrollbar width */
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:vertical {{
                background: {CONFIG['Controls']['hover-color']}; 
                min-height: 20px;
                border-radius: 2px;
            }}
            QScrollBar::handle:vertical:hover {{
                background: {CONFIG['CodeLine']['color']}; /* Darker on hover */
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                background: none; /* Hide arrows */
            }}

            /* Horizontal Scrollbar Customization */
            QScrollBar:horizontal {{
                border: none;
                background: white;
                height: 15px; /* Scrollbar height */
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:horizontal {{
                background: {CONFIG['Controls']['hover-color']};
                min-width: 20px;
                border-radius: 2px;
            }}
            QScrollBar::handle:horizontal:hover {{
                background: {CONFIG['CodeLine']['color']}; /* Darker on hover */
            }}
            QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{
                background: none; /* Hide arrows */
            }}
            """)

    def get_file_menu(self, pos: QPoint):
        index = self.tree.indexAt(pos)
        if not index.isValid():  # No item clicked
            return

        menu = QMenu(self)
        menu.setStyleSheet(f"""
                    QMenu {{background-color: #ffffff; border: 2px solid #ccc;}} 
                    QMenu::item {{padding: 4px 20px;}}
                    QMenu::item:selected {{background-color: #0078d7; color: white;}} 
                    QMenu::separator {{height: 1px; background: #ccc; margin: 5px 1;}}
                    """)
        load = menu.addAction("Load DataTable")
        unload = menu.addAction("Unload DataTable")
        
        action = menu.exec_(self.tree.viewport().mapToGlobal(pos))
        if action == load:
            self.filename.setText(f"[+] {index.data()}")
            item = self.model.itemFromIndex(index)
            if item.parent() is not None:
                self.highlight_active(item.parent().text(), item.text())
            else:
                self.highlight_active(item.text(), 'df')
            data_viewer = DATA_TABLE.get('data_viewer')
            if data_viewer:
                data_viewer.set_preview()
                data_viewer.set_sql()
                data_viewer.set_analysis()
                data_viewer.set_plots()
        elif action == unload:
            self.filename.setText(f"[-] {index.data()}")

    def add_file(self,file_name:str, file_path:str):
        GREY = QBrush(QColor("#9e9e9e"))
        item = QStandardItem(file_name)
        file_info = QFileInfo(file_path + '/' + file_name)
        icon = QFileIconProvider().icon(file_info)
        item.setIcon(icon)
        item.setForeground(GREY)
        self.tree.model().invisibleRootItem().appendRow(item)
    def add_subfile(self, parent_file:str,df_name:str='subfile'):
        matches = self.model.findItems(parent_file, Qt.MatchExactly)
        if not matches:
            return
        parent_item = matches[0]
        for row in range(parent_item.rowCount()):
            if parent_item.child(row).text() == df_name:
                return
        new_item = QStandardItem(df_name)
        new_item.setIcon(parent_item.icon())
        parent_item.appendRow(new_item)
        self.tree.expand(parent_item.index())

    def highlight_active(self, active_file: str, active_df: str = 'df'):
        PURPLE = QBrush(QColor("#7b1fa2"))
        GREY = QBrush(QColor("#9e9e9e"))
        root = self.model.invisibleRootItem()
        for file_row in range(root.rowCount()):
            file_item = root.child(file_row)
            is_active_file = file_item.text() == active_file
            file_item.setForeground(PURPLE if is_active_file else GREY)
            font = file_item.font()
            font.setBold(is_active_file)
            file_item.setFont(font)
            for df_row in range(file_item.rowCount()):
                df_item = file_item.child(df_row)
                is_active_df = is_active_file and df_item.text() == active_df
                df_item.setForeground(PURPLE if is_active_df else GREY)
                df_font = df_item.font()
                df_font.setBold(is_active_df)
                df_item.setFont(df_font)

class ListProjectsWorker(QThread):
    """Fetches GCP project IDs via Resource Manager API (ADC). Emits projects_ready(list) or projects_error(str)."""
    projects_ready = pyqtSignal(list)
    projects_error = pyqtSignal(str)

    def run(self):
        try:
            try:
                from google.cloud import resource_manager
                client = resource_manager.Client()
                ids = sorted([p.project_id for p in client.list_projects()])
            except ImportError:
                import importlib
                resourcemanager_v3 = importlib.import_module("google.cloud.resourcemanager_v3")
                client = resourcemanager_v3.ProjectsClient()
                ids = sorted([p.project_id for p in client.search_projects()])
            self.projects_ready.emit(ids)
        except Exception as e:
            self.projects_error.emit(str(e))

class PreferencesPanel(QWidget):
    PREFS_FILE = os.path.join(CURRENT_PATH, 'preferences.json')

    def __init__(self):
        super().__init__()
        self._prefs = self._load()

        layout = QVBoxLayout(self)
        layout.setContentsMargins(12, 16, 12, 12)
        layout.setSpacing(10)

        LABEL_STYLE = f"font: bold {CONFIG['FileExplorer']['font']}; color: {CONFIG['FileExplorer']['color']}; padding: 0px; background: transparent;"
        INPUT_STYLE = f'''
            QLineEdit {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['FileExplorer']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                padding: 6px 8px;
            }}
            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }}
        '''

        title = QLabel("Preferences")
        title.setStyleSheet(f"font: bold 15px -apple-system, 'SF Pro Text', 'Helvetica Neue', sans-serif; color: #1d1d1f; padding: 0 0 4px 0; background: transparent;")
        layout.addWidget(title)

        sep = QFrame()
        sep.setFrameShape(QFrame.HLine)
        sep.setStyleSheet("color: #e0e0e0; background: #e0e0e0; max-height: 1px;")
        layout.addWidget(sep)

        COMBO_STYLE = f'''
            QComboBox {{
                font: {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['CodeLine']['background-color']};
                border: {CONFIG['CodeLine']['border']};
                border-radius: {CONFIG['CodeLine']['border-radius']};
                padding: 5px 8px;
            }}
            QComboBox:focus {{
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }}
            QComboBox::drop-down {{
                border: none;
                width: 20px;
            }}
            QComboBox::down-arrow {{
                border: none;
                background: none;
            }}
            QComboBox QAbstractItemView {{
                background-color: white;
                border: 1px solid #e0e0e0;
                selection-background-color: {CONFIG['FileExplorer']['selection-color']};
                font: {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
            }}
        '''
        SECTION_STYLE = f"font: bold 13px -apple-system, 'SF Pro Text', sans-serif; color: #86868b; padding: 6px 0 0 0; background: transparent;"

        appearance_header = QLabel("Appearance")
        appearance_header.setStyleSheet(SECTION_STYLE)
        layout.addWidget(appearance_header)

        theme_label = QLabel("Theme")
        theme_label.setStyleSheet(LABEL_STYLE)
        layout.addWidget(theme_label)
        self.theme_combo = QComboBox()
        self.theme_combo.addItems(list(THEMES.keys()))
        current = self._prefs.get('theme', CURRENT_THEME)
        idx = self.theme_combo.findText(current)
        if idx >= 0:
            self.theme_combo.setCurrentIndex(idx)
        self.theme_combo.setStyleSheet(COMBO_STYLE)
        self.theme_combo.currentTextChanged.connect(self._on_theme_changed)
        layout.addWidget(self.theme_combo)

        icon_label = QLabel("Icon Set")
        icon_label.setStyleSheet(LABEL_STYLE)
        layout.addWidget(icon_label)
        self.icon_set_combo = QComboBox()
        self.icon_set_combo.addItems(['cloud', 'blueprint'])
        current_icon_set = self._prefs.get('icon_set', 'cloud')
        idx_icon = self.icon_set_combo.findText(current_icon_set)
        if idx_icon >= 0:
            self.icon_set_combo.setCurrentIndex(idx_icon)
        self.icon_set_combo.setStyleSheet(COMBO_STYLE)
        self.icon_set_combo.currentTextChanged.connect(self._on_theme_changed)
        layout.addWidget(self.icon_set_combo)

        self._apply_btn = QPushButton("Apply")
        self._apply_btn.setCursor(Qt.PointingHandCursor)
        self._apply_btn.setStyleSheet(f"""
            QPushButton {{
                font: bold {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 7px 20px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
            QPushButton:pressed {{
                background-color: #e8e8e8;
            }}
        """)
        self._apply_btn.clicked.connect(self._restart_app)
        self._apply_btn.hide()
        layout.addWidget(self._apply_btn)

        sep_appearance = QFrame()
        sep_appearance.setFrameShape(QFrame.HLine)
        sep_appearance.setStyleSheet("color: #e0e0e0; background: #e0e0e0; max-height: 1px;")
        layout.addWidget(sep_appearance)

        bq_header = QLabel("BigQuery")
        bq_header.setStyleSheet(f"font: bold 13px -apple-system, 'SF Pro Text', sans-serif; color: #86868b; padding: 6px 0 0 0; background: transparent;")
        layout.addWidget(bq_header)

        user_label = QLabel("Username (email)")
        user_label.setStyleSheet(LABEL_STYLE)
        layout.addWidget(user_label)
        self.user_field = QLineEdit()
        self.user_field.setPlaceholderText("user@company.com")
        self.user_field.setText(self._prefs.get('bq_username', ''))
        self.user_field.setStyleSheet(INPUT_STYLE)
        self.user_field.editingFinished.connect(self._save)
        layout.addWidget(self.user_field)

        project_label = QLabel("Default Project ID")
        project_label.setStyleSheet(LABEL_STYLE)
        layout.addWidget(project_label)
        self.project_field = QLineEdit()
        self.project_field.setPlaceholderText("my-gcp-project-id")
        self.project_field.setText(self._prefs.get('bq_project', ''))
        self.project_field.setStyleSheet(INPUT_STYLE)
        self.project_field.editingFinished.connect(self._save)
        layout.addWidget(self.project_field)

        self._bq_project_list = self._prefs.get('bq_project_list', [])
        self._bq_cached_label = QLabel(f"Cached: {len(self._bq_project_list)} projects")
        self._bq_cached_label.setStyleSheet(f"font: {CONFIG['FileExplorer']['font']}; color: #86868b; padding: 2px 0; background: transparent;")
        layout.addWidget(self._bq_cached_label)
        self._bq_refresh_btn = QPushButton("Refresh projects")
        self._bq_refresh_btn.setCursor(Qt.PointingHandCursor)
        self._bq_refresh_btn.setStyleSheet(f"""
            QPushButton {{
                font: bold {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 6px 14px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
            QPushButton:pressed {{ background-color: #e8e8e8; }}
        """)
        self._bq_refresh_btn.clicked.connect(self._refresh_bq_projects)
        layout.addWidget(self._bq_refresh_btn)
        self._list_projects_worker = None

        sep2 = QFrame()
        sep2.setFrameShape(QFrame.HLine)
        sep2.setStyleSheet("color: #e0e0e0; background: #e0e0e0; max-height: 1px;")
        layout.addWidget(sep2)

        general_header = QLabel("General")
        general_header.setStyleSheet(f"font: bold 13px -apple-system, 'SF Pro Text', sans-serif; color: #86868b; padding: 6px 0 0 0; background: transparent;")
        layout.addWidget(general_header)

        save_label = QLabel("Default Save Location")
        save_label.setStyleSheet(LABEL_STYLE)
        layout.addWidget(save_label)
        save_row = QHBoxLayout()
        save_row.setSpacing(4)
        self.save_field = QLineEdit()
        self.save_field.setPlaceholderText("~/Documents")
        self.save_field.setText(self._prefs.get('save_location', ''))
        self.save_field.setStyleSheet(INPUT_STYLE)
        self.save_field.editingFinished.connect(self._save)
        save_row.addWidget(self.save_field)

        browse_btn = QPushButton("…")
        browse_btn.setCursor(Qt.PointingHandCursor)
        browse_btn.setFixedWidth(36)
        browse_btn.setStyleSheet(f"""
            QPushButton {{
                font: bold 14px -apple-system;
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 5px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
        """)
        browse_btn.clicked.connect(self._browse_save_location)
        save_row.addWidget(browse_btn)
        layout.addLayout(save_row)

        layout.addStretch()

    def _load(self):
        try:
            with open(self.PREFS_FILE, 'r') as f:
                return json.load(f)
        except (FileNotFoundError, ValueError):
            return {}

    def _save(self):
        self._prefs = {
            'theme': self.theme_combo.currentText(),
            'icon_set': self.icon_set_combo.currentText(),
            'bq_username': self.user_field.text().strip(),
            'bq_project': self.project_field.text().strip(),
            'bq_project_list': getattr(self, '_bq_project_list', []),
            'save_location': self.save_field.text().strip(),
        }
        DATA_TABLE['preferences'] = self._prefs
        try:
            with open(self.PREFS_FILE, 'w') as f:
                json.dump(self._prefs, f, indent=2)
        except Exception:
            pass

    def _refresh_bq_projects(self):
        if getattr(self, '_list_projects_worker', None) and self._list_projects_worker.isRunning():
            return
        self._bq_refresh_btn.setEnabled(False)
        self._bq_cached_label.setText("Loading projects...")
        self._list_projects_worker = ListProjectsWorker()
        self._list_projects_worker.projects_ready.connect(self._on_bq_projects_ready)
        self._list_projects_worker.projects_error.connect(self._on_bq_projects_error)
        self._list_projects_worker.finished.connect(lambda: self._bq_refresh_btn.setEnabled(True))
        self._list_projects_worker.start()

    def _on_bq_projects_ready(self, project_ids):
        self._bq_project_list = project_ids
        self._save()
        self._bq_cached_label.setText(f"Cached: {len(project_ids)} projects")
        DATA_TABLE['preferences'] = self._prefs

    def _on_bq_projects_error(self, err_msg):
        self._bq_cached_label.setText(f"Error: {err_msg[:60]}{'...' if len(err_msg) > 60 else ''}")

    def _on_theme_changed(self, theme_name):
        self._save()
        self._apply_btn.show()

    def _restart_app(self):
        self._save()
        QApplication.instance().quit()
        os.execl(sys.executable, sys.executable, *sys.argv)

    def _browse_save_location(self):
        from PyQt5.QtWidgets import QFileDialog
        folder = QFileDialog.getExistingDirectory(self, "Select Save Location", self.save_field.text() or os.path.expanduser("~"))
        if folder:
            self.save_field.setText(folder)
            self._save()


class _BqTableFilterProxy(QSortFilterProxyModel):
    """Filters only table items; dataset (folder) rows are always visible."""
    def filterAcceptsRow(self, source_row, source_parent):
        if not self.filterRegExp().pattern():
            return True
        idx = self.sourceModel().index(source_row, 0, source_parent)
        item = self.sourceModel().itemFromIndex(idx)
        if not item:
            return True
        kind = item.data(Qt.UserRole + 1)
        if kind == 'dataset':
            for r in range(item.rowCount()):
                child = item.child(r)
                if child and child.data(Qt.UserRole + 1) == 'table':
                    if self.filterRegExp().indexIn(child.text()) >= 0:
                        return True
            return False
        if kind == 'table':
            return self.filterRegExp().indexIn(item.text()) >= 0
        return True

class BigQueryBrowser(QWidget):
    EXAMPLE_SQL = "SELECT * FROM `project.dataset.table` LIMIT 100"

    def __init__(self, file_tree=None, preferences=None):
        super().__init__()
        self._file_tree = file_tree
        self._client = None
        self._preferences = preferences

        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(8, 8, 8, 8)
        main_layout.setSpacing(0)

        INPUT_STYLE = f'''
            QLineEdit {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['FileExplorer']['color']};
                background-color:{CONFIG['CodeLine']['background-color']};
                border:{CONFIG['CodeLine']['border']};
                border-radius:{CONFIG['CodeLine']['border-radius']};
                padding: 4px 6px;
            }}
            QLineEdit:focus {{
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }}
        '''

        project_label = QLabel("Project ID")
        project_label.setStyleSheet(f"font: bold {CONFIG['FileExplorer']['font']}; color: {CONFIG['FileExplorer']['color']}; padding: 0px; background: transparent;")
        top_layout = QVBoxLayout()
        top_layout.setContentsMargins(0, 0, 0, 0)
        top_layout.setSpacing(6)
        top_widget = QWidget()
        top_widget.setLayout(top_layout)
        top_layout.addWidget(project_label)
        project_row = QHBoxLayout()
        project_row.setSpacing(4)
        COMBO_STYLE_BQ = f'''
            QComboBox {{
                font:{CONFIG['FileExplorer']['font']};
                color:{CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['CodeLine']['background-color']};
                border: {CONFIG['CodeLine']['border']};
                border-radius: {CONFIG['CodeLine']['border-radius']};
                padding: 4px 6px;
                min-height: 20px;
            }}
            QComboBox:focus {{
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }}
            QComboBox::drop-down {{
                border: none;
                width: 0;
                min-width: 0;
            }}
            QComboBox::down-arrow {{
                width: 0;
                height: 0;
                border: none;
            }}
        '''
        self.project_field = QComboBox()
        self.project_field.setEditable(True)
        self.project_field.setStyleSheet(COMBO_STYLE_BQ)
        self.project_field.installEventFilter(self)
        self.project_field.lineEdit().installEventFilter(self)
        self._populate_projects()
        project_row.addWidget(self.project_field)
        self._bq_refresh_btn = QPushButton("Refresh")
        self._bq_refresh_btn.setCursor(Qt.PointingHandCursor)
        self._bq_refresh_btn.setFixedHeight(24)
        self._bq_refresh_btn.setStyleSheet(f"""
            QPushButton {{
                font: {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 2px 8px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
            QPushButton:pressed {{ background-color: #e8e8e8; }}
        """)
        self._bq_refresh_btn.clicked.connect(self._refresh_bq_projects)
        project_row.addWidget(self._bq_refresh_btn)
        top_layout.addLayout(project_row)

        self.connect_btn = QPushButton("Connect")
        self.connect_btn.setCursor(Qt.PointingHandCursor)
        self.connect_btn.setStyleSheet(f"""
            QPushButton {{
                font: bold {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 7px 20px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
            QPushButton:pressed {{
                background-color: #e8e8e8;
            }}
        """)
        self.connect_btn.clicked.connect(self._connect)
        top_layout.addWidget(self.connect_btn)

        self.search_field = QLineEdit()
        self.search_field.setPlaceholderText("Search tables...")
        self.search_field.setStyleSheet(INPUT_STYLE)
        top_layout.addWidget(self.search_field)

        self.status_label = QTextEdit()
        self.status_label.setReadOnly(True)
        self.status_label.setFrameShape(QFrame.NoFrame)
        self.status_label.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.status_label.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.status_label.setMaximumHeight(80)
        self.status_label.setStyleSheet(f"font: {CONFIG['FileExplorer']['font']}; color: {CONFIG['CodeLine']['color']}; padding: 2px; background: transparent; border: none;")
        top_layout.addWidget(self.status_label)

        self.tree = QTreeView()
        self.tree.setHeaderHidden(True)
        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
        self.tree.customContextMenuRequested.connect(self._table_menu)
        self.tree.doubleClicked.connect(self._on_table_dblclick)
        self.model = QStandardItemModel()
        self.tree.setModel(self.model)
        self._bq_proxy = _BqTableFilterProxy()
        self._bq_proxy.setSourceModel(self.model)
        self._bq_proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self._bq_proxy.setFilterKeyColumn(0)
        self.tree.setModel(self._bq_proxy)
        self.search_field.textChanged.connect(self._bq_proxy.setFilterFixedString)

        sql_label = QLabel("SQL")
        sql_label.setStyleSheet(f"font: bold {CONFIG['FileExplorer']['font']}; color: {CONFIG['FileExplorer']['color']}; padding: 0px; background: transparent;")
        sql_section = QWidget()
        sql_layout = QVBoxLayout(sql_section)
        sql_layout.setContentsMargins(0, 0, 0, 0)
        sql_layout.setSpacing(6)
        sql_layout.addWidget(sql_label)

        self.sql_editor = QTextEdit()
        self.sql_editor.setPlaceholderText("SELECT * FROM `project.dataset.table` LIMIT 100")
        self.sql_editor.setMinimumHeight(80)
        self.sql_editor.setStyleSheet(f"""
            QTextEdit {{
                font: 13px Consolas, monospace;
                color: {CONFIG['CodeLine']['focus']['color']};
                background-color: {CONFIG['CodeLine']['focus']['background-color']};
                border: {CONFIG['CodeLine']['border']};
                border-radius: {CONFIG['CodeLine']['border-radius']};
                padding: 6px;
            }}
            QTextEdit:focus {{
                border-color: {CONFIG['CodeLine']['focus']['border-color']};
            }}
        """)
        self.sql_editor.installEventFilter(self)
        sql_layout.addWidget(self.sql_editor)

        self.run_btn = QPushButton("Run Query")
        self.run_btn.setCursor(Qt.PointingHandCursor)
        self.run_btn.setStyleSheet(f"""
            QPushButton {{
                font: bold {CONFIG['FileExplorer']['font']};
                color: {CONFIG['FileExplorer']['color']};
                background-color: {CONFIG['Controls']['background-color']};
                border: {CONFIG['Controls']['border']};
                border-radius: {CONFIG['Controls']['border-radius']};
                padding: 7px 20px;
            }}
            QPushButton:hover {{
                background-color: {CONFIG['Controls']['hover-color']};
                border: {CONFIG['Controls']['hover-border']};
            }}
            QPushButton:pressed {{
                background-color: #e8e8e8;
            }}
        """)
        self.run_btn.clicked.connect(self._run_sql)
        sql_layout.addWidget(self.run_btn)

        splitter = QSplitter(Qt.Vertical)
        splitter.addWidget(top_widget)
        splitter.addWidget(self.tree)
        splitter.addWidget(sql_section)
        splitter.setStretchFactor(0, 0)
        splitter.setStretchFactor(1, 1)
        splitter.setStretchFactor(2, 0)
        splitter.setSizes([180, 220, 200])
        main_layout.addWidget(splitter)

        self.setStyleSheet(f"""
            QWidget {{
                color: {CONFIG['FileExplorer']['color']};
                background-color: white;
                border-radius: 5px;
                padding: 2px;
            }}
            QTreeView {{
                background-color: white;
                font: {CONFIG['FileExplorer']['font']};
                border: {CONFIG['CodeLine']['border']};
            }}
            QTreeView::item {{
                padding: 2px;
            }}
            QTreeView::item:hover {{
                background-color: #e0e0e0;
            }}
            QTreeView::item:selected {{
                background-color: {CONFIG['FileExplorer']['selection-color']};
                color: white;
            }}
            QScrollBar:vertical {{
                border: none; background: white; width: 15px; margin: 0px;
            }}
            QScrollBar::handle:vertical {{
                background: {CONFIG['Controls']['hover-color']}; min-height: 20px; border-radius: 2px;
            }}
            QScrollBar::handle:vertical:hover {{
                background: {CONFIG['CodeLine']['color']};
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                background: none;
            }}
        """)

    def eventFilter(self, obj, event):
        if hasattr(self, 'sql_editor') and obj is self.sql_editor and event.type() == QEvent.FocusIn:
            if not self.sql_editor.toPlainText().strip():
                self.sql_editor.setPlainText(self.EXAMPLE_SQL)
        elif event.type() == QEvent.MouseButtonPress and (
            obj is self.project_field or obj is self.project_field.lineEdit()
        ):
            self.project_field.showPopup()
            return True
        return super().eventFilter(obj, event)

    def _set_status(self, text, color=None):
        if color is None:
            color = CONFIG['CodeLine']['color']
        self.status_label.setStyleSheet(f"font: {CONFIG['FileExplorer']['font']}; color: {color}; padding: 2px; background: transparent; border: none;")
        self.status_label.setPlainText(text)

    def _apply_defaults(self):
        prefs = DATA_TABLE.get('preferences', {})
        if not prefs and self._preferences:
            prefs = self._preferences._prefs
        if prefs.get('bq_project') and not self.project_field.currentText().strip():
            self.project_field.setCurrentText(prefs['bq_project'])

    def _populate_projects(self):
        prefs = DATA_TABLE.get('preferences', {})
        if not prefs and self._preferences:
            prefs = self._preferences._prefs
        project_list = prefs.get('bq_project_list', [])
        default = prefs.get('bq_project', '').strip()
        self.project_field.clear()
        if default and default not in project_list:
            self.project_field.addItem(default)
        for pid in project_list:
            self.project_field.addItem(pid)
        if default and self.project_field.findText(default) >= 0:
            self.project_field.setCurrentText(default)
        elif self.project_field.count() > 0:
            self.project_field.setCurrentIndex(0)

    def _refresh_bq_projects(self):
        if getattr(self, '_list_projects_worker', None) and self._list_projects_worker.isRunning():
            return
        self._bq_refresh_btn.setEnabled(False)
        self._set_status("Loading projects...")
        self._list_projects_worker = ListProjectsWorker()
        self._list_projects_worker.projects_ready.connect(self._on_bq_projects_ready)
        self._list_projects_worker.projects_error.connect(self._on_bq_projects_error)
        self._list_projects_worker.finished.connect(self._bq_refresh_worker_finished)
        self._list_projects_worker.start()

    def _on_bq_projects_ready(self, project_ids):
        prefs = DATA_TABLE.get('preferences', {}) or (self._preferences._prefs if self._preferences else {})
        prefs['bq_project_list'] = project_ids
        DATA_TABLE['preferences'] = prefs
        try:
            with open(PreferencesPanel.PREFS_FILE, 'w') as f:
                json.dump(prefs, f, indent=2)
        except Exception:
            pass
        if self._preferences:
            self._preferences._bq_project_list = project_ids
            self._preferences._bq_cached_label.setText(f"Cached: {len(project_ids)} projects")
        self._populate_projects()
        self._set_status(f"✓ {len(project_ids)} projects loaded", "#137333")

    def _on_bq_projects_error(self, err_msg):
        self._set_status(f"✗ {err_msg[:80]}", "#d93025")

    def _bq_refresh_worker_finished(self):
        self._bq_refresh_btn.setEnabled(True)

    def _on_table_dblclick(self, index):
        source_index = self._bq_proxy.mapToSource(index)
        item = self.model.itemFromIndex(source_index)
        if not item or item.data(Qt.UserRole + 1) != 'table':
            return
        table_id = item.data(Qt.UserRole)
        dataset_id = item.data(Qt.UserRole + 2)
        project = self.project_field.currentText().strip()
        self.sql_editor.setPlainText(
            f"SELECT *\nFROM `{project}.{dataset_id}.{table_id}`\nLIMIT 100"
        )

    def _get_billing_project(self):
        prefs = DATA_TABLE.get('preferences', {})
        if not prefs and self._preferences:
            prefs = self._preferences._prefs
        return prefs.get('bq_project', '').strip()

    def _connect(self):
        browse_project = self.project_field.currentText().strip()
        if not browse_project:
            self._set_status("⚠ Enter a Project ID", "#d93025")
            return

        billing_project = self._get_billing_project() or browse_project
        self._browse_project = browse_project

        self._set_status("Connecting...")
        QApplication.processEvents()

        try:
            from google.cloud import bigquery
            self._client = bigquery.Client(project=billing_project)
            datasets = list(self._client.list_datasets(project=browse_project))

            self.model.clear()
            root = self.model.invisibleRootItem()

            if not datasets:
                self._set_status(f"Connected to {browse_project} — no datasets found")
                return

            for ds in datasets:
                ds_item = QStandardItem(f"📁 {ds.dataset_id}")
                ds_item.setData(ds.dataset_id, Qt.UserRole)
                ds_item.setData('dataset', Qt.UserRole + 1)
                ds_item.setEditable(False)

                placeholder = QStandardItem("Loading...")
                placeholder.setData('placeholder', Qt.UserRole + 1)
                placeholder.setEditable(False)
                ds_item.appendRow(placeholder)

                root.appendRow(ds_item)

            try:
                self.tree.expanded.disconnect(self._on_expand)
            except (TypeError, RuntimeError):
                pass
            self.tree.expanded.connect(self._on_expand)
            self._set_status(f"✓ Connected — {len(datasets)} dataset(s)", "#137333")

        except Exception as e:
            self._set_status(f"✗ {str(e)}", "#d93025")

    def _on_expand(self, index):
        source_index = self._bq_proxy.mapToSource(index)
        item = self.model.itemFromIndex(source_index)
        if item and item.rowCount() == 1 and item.child(0).data(Qt.UserRole + 1) == 'placeholder':
            item.removeRow(0)
            dataset_id = item.data(Qt.UserRole)
            try:
                browse = getattr(self, '_browse_project', '') or self.project_field.currentText().strip()
                tables = list(self._client.list_tables(f"{browse}.{dataset_id}"))
                for t in tables:
                    icon = "📊" if t.table_type == "TABLE" else "👁" if t.table_type == "VIEW" else "📄"
                    tbl_item = QStandardItem(f"{icon} {t.table_id}")
                    tbl_item.setData(t.table_id, Qt.UserRole)
                    tbl_item.setData(dataset_id, Qt.UserRole + 2)
                    tbl_item.setData('table', Qt.UserRole + 1)
                    tbl_item.setEditable(False)
                    item.appendRow(tbl_item)
                if not tables:
                    empty = QStandardItem("(no tables)")
                    empty.setEditable(False)
                    item.appendRow(empty)
            except Exception as e:
                err = QStandardItem(f"Error: {str(e)[:80]}")
                err.setEditable(False)
                item.appendRow(err)

    def _table_menu(self, pos):
        index = self.tree.indexAt(pos)
        if not index.isValid():
            return
        source_index = self._bq_proxy.mapToSource(index)
        item = self.model.itemFromIndex(source_index)
        if item.data(Qt.UserRole + 1) != 'table':
            return

        menu = QMenu(self)
        menu.setStyleSheet(f"""
            QMenu {{background-color: #ffffff; border: 2px solid #ccc;}}
            QMenu::item {{padding: 4px 20px;}}
            QMenu::item:selected {{background-color: #4285f4; color: white;}}
            QMenu::separator {{height: 1px; background: #ccc; margin: 5px 1;}}
        """)
        load_action = menu.addAction("Load to DataViewer")
        preview_action = menu.addAction("Preview (100 rows)")

        action = menu.exec_(self.tree.viewport().mapToGlobal(pos))
        table_id = item.data(Qt.UserRole)
        dataset_id = item.data(Qt.UserRole + 2)
        project = self.project_field.currentText().strip()
        full_table = f"{project}.{dataset_id}.{table_id}"

        if action == load_action:
            self._load_table(full_table, table_id)
        elif action == preview_action:
            self._load_table(full_table, table_id, limit=100)

    def _load_table(self, full_table, table_name, limit=None):
        self._set_status(f"Loading {table_name}...")
        QApplication.processEvents()

        try:
            query = f"SELECT * FROM `{full_table}`"
            if limit:
                query += f" LIMIT {limit}"
            df = self._client.query(query).to_dataframe(create_bqstorage_client=False)
            self._load_query_result(df, table_name)

        except Exception as e:
            self._set_status(f"✗ {str(e)}", "#d93025")

    def _run_sql(self):
        query = self.sql_editor.toPlainText().strip()
        if not query:
            self._set_status("⚠ Enter a SQL query", "#d93025")
            return
        if not self._client:
            self._set_status("⚠ Connect to a project first", "#d93025")
            return

        self._set_status("Running query...")
        QApplication.processEvents()

        try:
            import re
            match = re.search(r'FROM\s+`?(?:[\w-]+\.)?([\w-]+)\.([\w-]+)`?', query, re.IGNORECASE)
            table_name = match.group(2) if match else "sql_result"

            df = self._client.query(query).to_dataframe(create_bqstorage_client=False)
            self._load_query_result(df, table_name)

        except Exception as e:
            import traceback
            traceback.print_exc()
            self._set_status(f"✗ {str(e)}", "#d93025")

    def _load_query_result(self, df, table_name):
        file_tree = self._file_tree or DATA_TABLE.get('file_tree')
        new_table = DataTable(file_tree=file_tree, df=df, file_name=table_name)
        DATA_TABLE['tables'].append(new_table)
        DATA_TABLE['current_table_index'] = len(DATA_TABLE['tables']) - 1

        if file_tree:
            file_tree.add_subfile(parent_file=table_name, df_name='df')
            file_tree.highlight_active(table_name, 'df')

        data_viewer = DATA_TABLE.get('data_viewer')
        if data_viewer:
            data_viewer.set_preview()
            data_viewer.set_edit()
            data_viewer.set_sql()
            data_viewer.set_analysis()
            data_viewer.set_plots()
            data_viewer.set_time()

        self._set_status(f"✓ Query returned {len(df):,} rows", "#137333")


# output widgets
class PlotOutput(QWidget):
    def __init__(self, fig=None, parent=None):
        super().__init__(parent)

        self.setStyleSheet("background-color: white; border: 2px solid #333;")

        self.layout = QVBoxLayout(self)
        self.setLayout(self.layout)

        if not fig:
            fig = plt.figure(figsize=(1,1))  # Explicit default size

        self.canvas = FigureCanvas(fig)
        self._apply_canvas_settings()
        self.layout.addWidget(self.canvas)

    def _apply_canvas_settings(self):
        if not hasattr(self.canvas, 'figure'):
            return
        self.canvas.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        w, h = self.canvas.figure.get_size_inches() * self.canvas.figure.dpi
        self.canvas.setMinimumSize(int(w), int(h))

    def set_plot(self, fig):
        self.canvas.setParent(None)
        if not fig:
            fig = plt.figure(figsize=(1,1))
        self.canvas = FigureCanvas(fig)
        self._apply_canvas_settings()
        self.layout.addWidget(self.canvas)
class TableOutput(QWidget):
    def __init__(self, df: pd.DataFrame = pd.DataFrame()):
        super().__init__()
        self._df = df

        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(0)
        layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)

        nrows = len(df)
        ncols = len(df.columns)
        table = QTableWidget(nrows, ncols)
        table.setHorizontalHeaderLabels([str(c) for c in df.columns])
        table.setVerticalHeaderLabels([str(i) for i in df.index])

        for row_idx in range(nrows):
            for col_idx in range(ncols):
                item = QTableWidgetItem(str(df.iat[row_idx, col_idx]))
                item.setFlags(item.flags() & ~Qt.ItemIsEditable)
                table.setItem(row_idx, col_idx, item)

        table.setAlternatingRowColors(True)
        table.setShowGrid(True)
        table.setStyleSheet(f"""
            QTableWidget {{
                font: 11px Ubuntu;
                color: #333333;
                background-color: white;
                alternate-background-color: #fafafa;
                border: none;
                border-radius: 2px;
                padding: 0px;
                gridline-color: #e8e8e8;
            }}
            QTableWidget::item {{
                padding: 2px 5px;
            }}
            QHeaderView::section {{
                font: 11px Ubuntu;
                color: #333333;
                background-color: #f5f5f5;
                padding: 3px 5px;
                border: none;
                border-right: 1px solid #e8e8e8;
                border-bottom: none;
            }}
            QTableWidget QTableCornerButton::section {{
                background-color: #f5f5f5;
                border: none;
                border-right: 1px solid #e8e8e8;
                border-bottom: none;
            }}
            QScrollBar:vertical {{
                border: none;
                background: #fafafa;
                width: 8px;
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:vertical {{
                background: #c1c1c1;
                min-height: 20px;
                border-radius: 2px;
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                background: none;
            }}
            QScrollBar:horizontal {{
                border: none;
                background: #fafafa;
                height: 8px;
                margin: 0px;
                border-radius: 0px;
            }}
            QScrollBar::handle:horizontal {{
                background: #c1c1c1;
                min-width: 20px;
                border-radius: 2px;
            }}
            QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{
                background: none;
            }}
        """)

        header = table.horizontalHeader()
        header.setStyleSheet("""
            QHeaderView::section {
                font: 11px Ubuntu;
                color: #333333;
                background-color: #f5f5f5;
                padding: 3px 5px;
                border: none;
                border-right: 1px solid #e8e8e8;
                border-bottom: 2px solid #333333;
            }
        """)
        for col in range(ncols):
            header.setSectionResizeMode(col, QHeaderView.ResizeToContents)
        header.resizeSections(QHeaderView.ResizeToContents)
        table.horizontalHeader().setStretchLastSection(True)
        table.verticalHeader().setDefaultSectionSize(18)
        table.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        table.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        row_height = table.rowHeight(1)
        header_height = table.horizontalHeader().sizeHint().height()
        max_table_height = 600
        total_height = header_height + row_height * max(nrows, 0) + 4
        table.setFixedHeight(min(total_height, max_table_height))

        layout.addWidget(table)
        self.setLayout(layout)
class TextOutput(QWidget):
    def __init__(self,text:str='output text'):
        super().__init__()    

        self._text = text
        MAX_TEXT_HEIGHT = 600
        HEIGHT_SCROLL_THRESHOLD,WIDTH_SCROLL_THRESHOLD = 20,200
        
        LABEL_STYLE = f"""
            QLabel {{
                font: {CONFIG['Output']['font']};
                color: {CONFIG['Output']['color']};
                background-color: white; 
                padding: 1px 30px; 
                border-radius: {CONFIG["Controls"]["border-radius"]};
                border: 0px solid white;
            }}
        """
        self.layout = QVBoxLayout()
        self.layout.setAlignment(Qt.AlignTop)
        self.layout.setSpacing(0)
        
        self.outbox = QLabel(self._text)
        self.outbox.setTextInteractionFlags(Qt.TextSelectableByMouse)
        self.outbox.setWordWrap(False)
        self.outbox.setAlignment(Qt.AlignLeft)
        self.outbox.setStyleSheet(LABEL_STYLE) 
        
        if self._text.count('\n') > HEIGHT_SCROLL_THRESHOLD or len(self._text.split('\n')[0]) > WIDTH_SCROLL_THRESHOLD:
            scroll_area = QScrollArea(self)
            scroll_area.setWidget(self.outbox)
            scroll_area.setWidgetResizable(True)
            scroll_area.setFixedHeight(min(20*(1 + self._text.count('\n')),MAX_TEXT_HEIGHT))
            scroll_area.setStyleSheet(f"""
                QScrollArea {{
                    color: {CONFIG['FileExplorer']['color']};
                    background-color: white;
                    border-radius: 1px;
                    border: 0px solid white;
                    width: 1500;
                    padding: 2px;
                }}
                /* Scrollbar Customization */
                QScrollBar:vertical {{
                    border: none;
                    background: white; 
                    width: 10px; /* Scrollbar width */
                    margin: 0px;
                    border-radius: 0px;
                }}
                QScrollBar::handle:vertical {{
                    background: {CONFIG['Controls']['hover-color']}; 
                    min-height: 20px;
                    border-radius: 2px;
                }}
                QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                    background: none; /* Hide arrows */
                }}

                /* Horizontal Scrollbar Customization */
                QScrollBar:horizontal {{
                    border: none;
                    background: white;
                    height: 15px; /* Scrollbar height */
                    margin: 0px;
                    border-radius: 0px;
                }}
                QScrollBar::handle:horizontal {{
                    background: {CONFIG['Controls']['hover-color']};
                    min-width: 10px;
                    border-radius: 2px;
                }}
                QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{
                    background: none; /* Hide arrows */
                }}
            """)
            self.layout.addWidget(scroll_area)
        else:
            self.layout.addWidget(self.outbox)

        self.setLayout(self.layout)
class AnalysisOutput(QWidget):
    def __init__(self,plot,log:str='',table:pd.DataFrame=pd.DataFrame()):
        super().__init__()

        #self._height = 1300 # height

        self.setStyleSheet("background-color: #f0f0f0; border: 2px solid #333;")
        
        self.layout = QVBoxLayout()
        self.layout.addWidget(TextOutput(text=log))
        self.layout.addWidget(TableOutput(df=table))
        self.layout.addWidget(PlotOutput(fig=plot))
        self.setLayout(self.layout)
        #self.setFixedHeight(self.layout.sizeHint().height())