import dearpygui.dearpygui as dpg
import configparser
import os
import csv
import pandas as pd
from pandas import DataFrame, concat
from tqdm import tqdm
from loguru import logger
from paramiko import SSHClient, AutoAddPolicy
import time
import re
 
# Set up logging once at the start
logger.add(os.getcwd() + "\\FID_{time:YYYY-MM-DD}.log", rotation='00:00', retention='3 days',
           format="[{time:YYYY-MM-DD HH:mm:ss}] {level} - {message}")
 
def run_group_fid_char_limit(config, output_folder):
    ssh = query_ssh(config)
    slash_id = config.get("data", "slash_id")
    samechar = config.get("data", "samechar")
    cmd = f'frpt {slash_id} -samechar=/{samechar}/ +charlimit'
    output = exec_ssh_cmd(cmd, ssh)
    
    file_name = f'{config.get("data", "foldername")}.txt'
    file_path = os.path.join(output_folder, file_name)
    
    with open(file_path, 'w') as file:
        file.write(output)
    
    logger.success(f'Saved results to {file_name}')
    ssh.close()
 
# Common utility functions
def exec_ssh_cmd(cmd, ssh):
    ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(cmd)
    return ssh_stdout.read().decode("utf-8")
 
def query_ssh(config):
    ssh = SSHClient()
    ssh.set_missing_host_key_policy(AutoAddPolicy())
    server = config.get('data', 'server')
    user = config.get('data', 'user')
    pwd = config.get('data', 'pwd')
    ssh.connect(server, username=user, password=pwd, allow_agent=True, port=22)
    logger.info(f'Connect to {server} success~')
    return ssh
 
# Test type: "char value" (originally FID.py from section 2)
def run_char_value(config, output_folder):
    def get_info_provide_by_user(config):
        fid = config.get('data', 'fid', fallback='')
        # Split by both commas and whitespace, then filter out empty strings
        import re
        fids = [f.strip() for f in re.split(r'[,\s]+', fid) if f.strip()]
        if not fids:
            logger.error('No FID found in config.ini')
            return None
        df = DataFrame(fids, columns=['FID'])
        logger.info('-----The data to be queried are as follows-----')
        print(df)
        return df
 
    def get_test_result(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, samechar):
        cmd = f'fdat95 {SLASH} +charonly -samechar=/{samechar}/ -fgrp=/@FID_List/ +archive'
        logger.info(f'Execute fdat95 cmd {SLASH}')
        output = exec_ssh_cmd(cmd, ssh)
        main_list = []
        column = ['FID']
        j = 0
        for line in output.splitlines():
            if ':' in line:
                line = re.sub(r'=\s+', '=', line)
                temp_list = line.split()[1:]
                if j == 0:
                    for i in range(len(temp_list)):
                        if i > 0:
                            column.append(temp_list[i].split("=")[0])
                            temp_list[i] = temp_list[i].split("=")[1]
                    j += 1
                else:
                    for i in range(len(temp_list)):
                        if i > 0:
                            temp_list[i] = temp_list[i].split("=")[1]
                main_list.append(temp_list)
        df_result = DataFrame(main_list, columns=column)
        if not df_result.empty:
            # Generate base filename
            file_name = f'{Step}_{SLASH}_{Test_Result}_{Test_Time}.csv'
            file_name = file_name.replace(' ', '_').replace('/', '').replace(':', '_')
           
            # Handle duplicate filenames
            base, ext = os.path.splitext(file_name)
            counter = 1
            new_file_name = file_name
            output_path = os.path.join(output_folder, new_file_name)
           
            while os.path.exists(output_path):
                new_file_name = f"{base}({counter}){ext}"
                output_path = os.path.join(output_folder, new_file_name)
                counter += 1
           
            df_result.to_csv(output_path, index=False)
            logger.info(f'Saved results to {new_file_name}')
 
    def get_all_fid(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, samechar):
        cmd = f'fdat95 {SLASH} -hurl=/eng/'
        logger.info('Execute ' + cmd)
        output = exec_ssh_cmd(cmd, ssh)
        main_list = []
        for line in output.splitlines():
            if ':' in line:
                main_list.append(line.split()[1])
        df_FID = DataFrame(main_list, columns=['FID']).drop_duplicates()
        if not df_FID.empty:
            df_FID.to_csv('FID_List.csv', index=False)
            time.sleep(2)
            sftp = ssh.open_sftp()
            sftp.put('FID_List.csv', f'/home/{config.get("data", "user")}/FID_List.csv')
            time.sleep(2)
            get_test_result(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, config.get('data', 'samechar'))
            sftp.close()
 
    def get_slash(df, output_folder, config):
        ssh = query_ssh(config)
        main_list = []
        for i in tqdm(range(df.shape[0])):
            FID = df.loc[i, "FID"]
            cmd = f"fid {FID} -o -mtime -substep "
            logger.info('Execute ' + cmd)
            output = exec_ssh_cmd(cmd, ssh)
            for line in output.splitlines():
                if 'HSRT' in line or 'CFIN' in line or 'AQLK' in line:
                    temp_list = line.split()
                    temp_list.insert(0, FID)
                    temp_list[4] = temp_list[4] + ' ' + temp_list[5]
                    temp_list.pop(5)
                    main_list.append(temp_list)
            data = DataFrame(main_list, columns=['FID', 'SLASH', 'Test_Result', 'Step', 'Test_Time'])
            main_list.clear()
            if not data.empty:
                for row in data.itertuples(index=False):
                    get_all_fid(ssh, row.SLASH, row.Test_Result, row.Test_Time, row.FID, row.Step, output_folder, config.get('data', 'samechar'))
        ssh.close()
 
    df_User = get_info_provide_by_user(config)
    if df_User is not None and not df_User.empty:
        get_slash(df_User, output_folder, config)
 
# Test type: "slash lot" (originally "fail bits", originally slash.py from section 5)
def run_slash_lot(config, output_folder):
    def get_slash_values():
        csv_path = os.path.join(os.getcwd(), 'slash.csv')
        try:
            df = pd.read_csv(csv_path)
            if 'slash' not in df.columns:
                raise KeyError("'slash' column not found in slash.csv")
            if 'STEP' not in df.columns:
                raise KeyError(
                    "Second column must be named 'STEP' but was not found in slash.csv. "
                    "Please add a 'STEP' column with a step label for each slash."
                )
            logger.info('----- SLASH / STEP pairs to process -----')
            pairs = df[['slash', 'STEP']].dropna(subset=['slash'])
            logger.info(pairs.to_string(index=False))
            return list(zip(pairs['slash'], pairs['STEP'].fillna('')))
        except FileNotFoundError:
            logger.error("slash.csv file not found in directory")
            return []
        except Exception as e:
            logger.error(f"Error reading slash.csv: {str(e)}")
            return []
 
    def sort_by_fid_priority(df, priority_fids):
        """Sort DataFrame by FID priority, moving matching FIDs to top"""
        if df.empty or not priority_fids:
            return df
       
        # Create a copy to avoid modifying original
        df_copy = df.copy()
       
        # Split into priority and non-priority rows
        priority_rows = []
        other_rows = []
       
        for _, row in df_copy.iterrows():
            fid_value = str(row.iloc[0])  # First column (FID)
            if any(fid in fid_value for fid in priority_fids):
                priority_rows.append(row)
            else:
                other_rows.append(row)
       
        # Sort priority rows by the order of FIDs in priority_fids
        def get_fid_priority(row):
            fid_value = str(row.iloc[0])
            for i, fid in enumerate(priority_fids):
                if fid in fid_value:
                    return i
            return len(priority_fids)  # Put at end if not found
       
        priority_rows.sort(key=get_fid_priority)
       
        # Combine priority rows first, then other rows
        if priority_rows:
            priority_df = DataFrame(priority_rows)
            if other_rows:
                other_df = DataFrame(other_rows)
                result_df = concat([priority_df, other_df], ignore_index=True)
            else:
                result_df = priority_df.reset_index(drop=True)
        else:
            result_df = DataFrame(other_rows).reset_index(drop=True) if other_rows else df_copy
       
        return result_df
 
    def check_die_pattern_and_filter(df, num_die):
        """Check if any value in B2 to B33 of second row appears num_die times,
        and filter out repeated rows if it matches"""
        if df.empty or len(df) < 2 or num_die <= 0:
            return df, True  # Return original df and success status
       
        # Get the second row (index 1) and check B2 to B33 (columns 1 to 32)
        if len(df.columns) < 33:  # Need at least 33 columns (FID + 32 data columns)
            logger.warning(f"Not enough columns for die pattern check. Expected at least 33, got {len(df.columns)}")
            return df, True
       
        second_row = df.iloc[1]
        # Get values from columns 1 to 32 (B2 to B33 in Excel terms)
        b2_to_b33_values = second_row.iloc[1:33].tolist()
       
        # Count occurrences of each value
        from collections import Counter
        value_counts = Counter(str(val) for val in b2_to_b33_values)
       
        # Check if any value appears exactly num_die times
        pattern_matches = False
        matching_value = None
        for value, count in value_counts.items():
            if count == num_die:
                pattern_matches = True
                matching_value = value
                logger.info(f"Found value '{value}' appearing {count} times in B2:B33, matching num_die={num_die}")
                break
       
        if not pattern_matches:
            logger.info(f"No value in B2:B33 appears exactly {num_die} times")
            logger.info(f"Value counts: {dict(value_counts)}")
            return df, False
       
        logger.info(f"Die pattern matches: value '{matching_value}' appears {num_die} times")
        logger.info(f"Applying filter: keeping header row and every {num_die}-th data row starting from row 2")
       
        # Filter rows: Always keep header (row 0), then keep row 1, 1+num_die, 1+2*num_die, etc.
        filtered_rows = []
       
        # Always keep the header row (index 0)
        filtered_rows.append(df.iloc[0])
       
        # Filter data rows starting from index 1 (Excel row 2)
        # Keep rows at indices: 1, 1+num_die, 1+2*num_die, 1+3*num_die, etc.
        for i in range(1, len(df)):
            if (i - 1) % num_die == 0:  # Keep every num_die-th row starting from index 1
                filtered_rows.append(df.iloc[i])
       
        filtered_df = DataFrame(filtered_rows).reset_index(drop=True)
        logger.info(f"Filtered from {len(df)} rows to {len(filtered_df)} rows (including header)")
        return filtered_df, True
 
    def process_slash(slash, step, output_folder, config):
        ssh = query_ssh(config)
        cmd = f'fdat95 {slash} -samechar=/{config.get("data", "samechar")}/ +charonly +archive'
        logger.info(f'Executing: {cmd}')
        output = exec_ssh_cmd(cmd, ssh)
        separate_channel = config.get('data', 'separate_channel', fallback='False') == 'True'

        if separate_channel:
            all_rows = []
            ordered_columns = ['FID']
            for line in output.splitlines():
                if line.startswith('%') and ':' in line:
                    line = re.sub(r'=\s+', '=', line)
                    parts = line.split()[1:]
                    row_dict = {'FID': parts[0]}
                    for item in parts[1:]:
                        if '=' in item:
                            col, val = item.split('=', 1)
                            row_dict[col] = val
                            if col not in ordered_columns:
                                ordered_columns.append(col)
                    all_rows.append(row_dict)
            if not all_rows:
                ssh.close()
                return
            sanitized_slash = re.sub(r'[\\/:*?"<>|]', '_', slash)
            sanitized_step = re.sub(r'[\\/:*?"<>|]', '_', str(step)).strip()
            filename = f"{sanitized_step}_{sanitized_slash}.csv" if sanitized_step else f"{sanitized_slash}.csv"
            df = DataFrame(all_rows, columns=ordered_columns).fillna('')
        else:
            main_list = []
            columns = ['FID']
            for line in output.splitlines():
                if line.startswith('%') and ':' in line:
                    line = re.sub(r'=\s+', '=', line)
                    parts = line.split()[1:]
                    if not main_list:
                        columns += [item.split('=')[0] for item in parts[1:]]
                    main_list.append([parts[0], *[item.split('=')[1] if '=' in item else '' for item in parts[1:]]])
            if not main_list:
                ssh.close()
                return
            max_cols = max(len(row) for row in main_list)
            while len(columns) < max_cols:
                columns.append(f'extra_col_{len(columns)}')
            for i in range(len(main_list)):
                if len(main_list[i]) < max_cols:
                    main_list[i] += [''] * (max_cols - len(main_list[i]))
            sanitized_slash = re.sub(r'[\\/:*?"<>|]', '_', slash)
            sanitized_step = re.sub(r'[\\/:*?"<>|]', '_', str(step)).strip()
            filename = f"{sanitized_step}_{sanitized_slash}.csv" if sanitized_step else f"{sanitized_slash}.csv"
            df = DataFrame(main_list, columns=columns)

        if not df.empty:
            # Apply FID sorting if FIDs are specified
            fid_input = config.get('data', 'fid', fallback='').strip()
            if fid_input:
                priority_fids = [f.strip() for f in re.split(r'[,\s\n\r]+', fid_input) if f.strip()]
                if priority_fids:
                    df = sort_by_fid_priority(df, priority_fids)
                    logger.info(f'Applied FID priority sorting for: {priority_fids}')
    
    
    
            # Apply die number filtering if specified
    
            num_die_input = config.get('data', 'num_die', fallback='').strip()
            if num_die_input and num_die_input.isdigit():
                num_die = int(num_die_input)
                df, success = check_die_pattern_and_filter(df, num_die)
                if not success:
                    logger.warning("Die pattern doesn't match - continuing without filtering")
            output_path = os.path.join(output_folder, filename)
            df.to_csv(output_path, index=False)
            logger.success(f'Saved {len(df)} records to {filename}')
    
        ssh.close()
 
    slash_pairs = get_slash_values()
    for slash, step in tqdm(slash_pairs, desc='Processing SLASH values'):
        process_slash(slash, step, output_folder, config)
 
# Test type: "single char value" (originally Single_Char_Value.py from section 4)
def run_single_char_value(config, output_folder):
    all_data = []
 
    def get_info_provide_by_user(config):
        fid = config.get('data', 'fid', fallback='')
        fids = [f.strip() for f in fid.split(',') if f.strip()]
        if not fids:
            logger.error('No FID found in config.ini')
            return None
        df = DataFrame(fids, columns=['FID'])
        logger.info('-----The data to be queried are as follows-----')
        print(df)
        return df
 
    def get_test_result(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, samechar):
        cmd = f'fdat95 {SLASH} +charonly -samechar=/{samechar}/ -fgrp=/{FID}/ +archive'
        logger.info(f'Execute fdat95 cmd {SLASH}')
        output = exec_ssh_cmd(cmd, ssh)
        main_list = []
        column = ['FID']
        j = 0
        for line in output.splitlines():
            if ':' in line:
                line = re.sub(r'=\s+', '=', line)
                temp_list = line.split()[1:]
                if j == 0:
                    for i in range(len(temp_list)):
                        if i > 0:
                            column.append(temp_list[i].split("=")[0])
                            temp_list[i] = temp_list[i].split("=")[1]
                    j += 1
                else:
                    for i in range(len(temp_list)):
                        if i > 0:
                            temp_list[i] = temp_list[i].split("=")[1]
                main_list.append(temp_list)
        if main_list:
            df_result = DataFrame(main_list, columns=column)
            df_result['Test_Time'] = Test_Time
            df_result['Step'] = Step
            df_result['Test_Result'] = Test_Result
            all_data.append(df_result)
 
    def get_all_fid(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, samechar):
        cmd = f'fdat95 {SLASH} -hurl=/eng/'
        logger.info('Execute ' + cmd)
        output = exec_ssh_cmd(cmd, ssh)
        main_list = []
        for line in output.splitlines():
            if ':' in line:
                main_list.append(line.split()[1])
        df_FID = DataFrame(main_list, columns=['FID']).drop_duplicates()
        if not df_FID.empty:
            df_FID.to_csv('FID_List.csv', index=False)
            time.sleep(2)
            sftp = ssh.open_sftp()
            sftp.put('FID_List.csv', f'/home/{config.get("data", "user")}/FID_List.csv')
            time.sleep(2)
            get_test_result(ssh, SLASH, Test_Result, Test_Time, FID, Step, output_folder, config.get('data', 'samechar'))
            sftp.close()
 
    def get_slash(df, output_folder, config):
        ssh = query_ssh(config)
        main_list = []
        for i in tqdm(range(df.shape[0])):
            FID = df.loc[i, "FID"]
            cmd = f"fid {FID} -o -mtime -substep "
            logger.info('Execute ' + cmd)
            output = exec_ssh_cmd(cmd, ssh)
            for line in output.splitlines():
                if 'HSRT' in line or 'CFIN' in line or 'AQLK' in line:
                    temp_list = line.split()
                    temp_list.insert(0, FID)
                    temp_list[4] = temp_list[4] + ' ' + temp_list[5]
                    temp_list.pop(5)
                    main_list.append(temp_list)
            if main_list:
                data = DataFrame(main_list, columns=['FID', 'SLASH', 'Test_Result', 'Step', 'Test_Time'])
                main_list.clear()
                for row in data.itertuples(index=False):
                    get_all_fid(ssh, row.SLASH, row.Test_Result, row.Test_Time, row.FID, row.Step, output_folder, config.get('data', 'samechar'))
        ssh.close()
 
    df_User = get_info_provide_by_user(config)
    if df_User is not None and not df_User.empty:
        get_slash(df_User, output_folder, config)
        if all_data:
            combined_df = concat(all_data, ignore_index=True)
            combined_df.insert(0, 'test time with substep (status)',
                              combined_df['Test_Time'] + ' - ' +
                              combined_df['Step'] + ' (' +
                              combined_df['Test_Result'].str.upper() + ')')
            combined_df.drop(['Test_Time', 'Step', 'Test_Result'], axis=1, inplace=True)
            output_path = os.path.join(output_folder, 'combined_results.csv')
            combined_df.to_csv(output_path, index=False)
            logger.success(f'Saved final results to {output_path}')
 
# Test type: "group fid char value" (originally GroupFid_Charvalue.py from section 3)
def run_group_fid_char_value(config, output_folder):
    all_data = []
 
    def get_pending_fids():
        csv_path = os.path.join(os.getcwd(), 'Pending_FID.csv')
        try:
            df = pd.read_csv(csv_path)
            if 'FID' not in df.columns:
                raise KeyError("'FID' column not found in Pending_FID.csv")
            logger.info('----- FIDs to process -----')
            logger.info(df['FID'].to_string(index=False))
            return df['FID'].dropna().unique().tolist()
        except FileNotFoundError:
            logger.error("Pending_FID.csv file not found in directory")
            return []
        except Exception as e:
            logger.error(f"Error reading Pending_FID.csv: {str(e)}")
            return []
 
    def process_fid(fid, all_data, config):
        ssh = query_ssh(config)
        cmd = f'fdat95 {config.get("data", "slash_id")} -samechar=/{config.get("data", "samechar")}/ -fgrp=/{fid}/ +charonly +archive'
        logger.info(f'Executing: {cmd}')
        output = exec_ssh_cmd(cmd, ssh)
        main_list = []
        columns = ['FID']
        for line in output.splitlines():
            if line.startswith('%') and ':' in line:
                line = re.sub(r'=\s+', '=', line)
                parts = line.split()[1:]
                if not main_list:
                    columns += [item.split('=')[0] for item in parts[1:]]
                main_list.append([fid, *[item.split('=')[1] if '=' in item else '' for item in parts[1:]]])
        if main_list:
            df = DataFrame(main_list, columns=columns)
            all_data.append(df)
        ssh.close()
 
    fids = get_pending_fids()
    for fid in tqdm(fids, desc='Processing FIDs'):
        process_fid(fid, all_data, config)
    if all_data:
        combined_df = concat(all_data, ignore_index=True)
        result_file_path = os.path.join(output_folder, 'result.csv')
        combined_df.to_csv(result_file_path, index=False)
        logger.success(f'Combined results saved to {result_file_path}')
 
# GUI callback
def submit_callback():
    username = dpg.get_value("Username")
    password = dpg.get_value("Password")
    server = dpg.get_value("Server")
    char_type = dpg.get_value("test type")
    samechar = dpg.get_value("Samechar")
    fid = dpg.get_value("FID")
    foldername = dpg.get_value("Folder")
    num_die = dpg.get_value("num_die")
    separate_channel = dpg.get_value("separate_channel")

    config = configparser.ConfigParser()
    config["data"] = {
        "samechar": samechar,
        "server": server,
        "user": username,
        "pwd": password,
        "chartype": char_type,
        "fid": fid,
        "foldername": foldername,
        "num_die": num_die,
        "separate_channel": str(separate_channel)
    }
    if char_type == "group fid char value" or char_type == "group fid char limit":
        slash_id = dpg.get_value("slash_id")
        config["data"]["slash_id"] = slash_id   
 
    try:
        with open("config.ini", "w") as configfile:
            config.write(configfile)
    except Exception as e:
        dpg.set_value("result_text", f"File creation failed: {str(e)}")
        return
 
    config.read("config.ini")
    output_folder = config.get('data', 'foldername')
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
 
    if char_type == "char value":
        run_char_value(config, output_folder)
    elif char_type == "slash lot":
        run_slash_lot(config, output_folder)
    elif char_type == "single char value":
        run_single_char_value(config, output_folder)
    elif char_type == "group fid char value":
        run_group_fid_char_value(config, output_folder)
    elif char_type == "group fid char limit":
        run_group_fid_char_limit(config, output_folder)
    else:
        dpg.set_value("result_text", "Invalid test type selected.")
        return
 
    dpg.set_value("result_text", "Execution completed.")
 
# GUI setup functions
def version_window():
    with dpg.window(label="version details", tag="popup window", show=False, width=500, height=300):
        dpg.add_text("2025/2/27 first version \n2025/3/3 second version \n2025/7/23 The third version. Add \"FID\" and \"number of die\" function in slash lot")
 
def version_window_showup():
    dpg.configure_item("popup window", show=True)
 
def acknowledgement_window():
    with dpg.window(label="Acknowledgement", tag="ack window", show=False, width=500, height=300):
        dpg.add_text("Thanks Leo and Jojo's help!")
 
def ack_window_showup():
    dpg.configure_item("ack window", show=True)
 
def combo_callback():
    selected = dpg.get_value("test type")
    if selected == "char value":
        dpg.configure_item("FID", show=True)
        dpg.configure_item("Samechar", show=True)
        dpg.configure_item("slash_id", show=False)
        dpg.configure_item("num_die", show=False)
        dpg.configure_item("separate_channel", show=False)
    elif selected == "slash lot":
        dpg.configure_item("FID", show=True)
        dpg.configure_item("Samechar", show=True)
        dpg.configure_item("slash_id", show=False)
        dpg.configure_item("num_die", show=True)
        dpg.configure_item("separate_channel", show=True)
    elif selected == "single char value":
        dpg.configure_item("FID", show=True)
        dpg.configure_item("Samechar", show=True)
        dpg.configure_item("slash_id", show=False)
        dpg.configure_item("num_die", show=False)
        dpg.configure_item("separate_channel", show=False)
    elif selected == "group fid char limit":
        dpg.configure_item("FID", show=False)
        dpg.configure_item("Samechar", show=True)
        dpg.configure_item("slash_id", show=True)
        dpg.configure_item("num_die", show=False)
        dpg.configure_item("separate_channel", show=False)
    elif selected == "group fid char value":
        dpg.configure_item("FID", show=False)
        dpg.configure_item("Samechar", show=True)
        dpg.configure_item("slash_id", show=True)
        dpg.configure_item("num_die", show=False)
        dpg.configure_item("separate_channel", show=False)
 
# GUI initialization
config = configparser.ConfigParser()
saved_user = saved_pwd = saved_server = saved_chartype = ""
if os.path.exists("config.ini"):
    config.read("config.ini")
    if config.has_section("data"):
        saved_user = config.get("data", "user", fallback="")
        saved_pwd = config.get("data", "pwd", fallback="")
        saved_server = config.get("data", "server", fallback="")
        saved_chartype = config.get("data", "chartype", fallback="")
 
dpg.create_context()
with dpg.font_registry():
    default_font = dpg.add_font(file="C:\\Windows\\Fonts\\ARLRDBD.TTF", size=30)
dpg.bind_font(default_font)
dpg.create_viewport(title="Automated Char Value 1.2", width=600, height=600)
dpg.setup_dearpygui()
 
version_window()
acknowledgement_window()
 
with dpg.window(tag="MainWindow", label="Input Parameters", width=600, height=600):
    with dpg.menu_bar(label="Main Menu Bar"):
        dpg.add_menu_item(label="Version Details", callback=version_window_showup)
        dpg.add_menu_item(label="Acknowledgement", callback=ack_window_showup)
    with dpg.group(horizontal=True):
        dpg.add_input_text(tag="Username", hint="Username", width=200, default_value=saved_user)
        dpg.add_input_text(tag="Password", hint="PWD", password=True, width=200, default_value=saved_pwd)
    dpg.add_input_text(tag="Server", hint="Server", width=200, default_value=saved_server)
    dpg.add_input_text(tag="Folder", hint="Folder name", width=200, default_value="")
    dpg.add_combo(tag="test type", items=["single char value", "char value", "slash lot", "group fid char value", "group fid char limit"], 
              label="Test Type", callback=combo_callback, width=300)
    dpg.add_input_text(tag="Samechar", hint="Samechar", width=200, show=False)
    dpg.add_input_text(tag="FID", hint="FID", width=400, show=False)
    dpg.add_input_text(tag="slash_id", hint="slash id", width=400, show=False)
    dpg.add_input_text(tag="num_die", hint="number of die (numbers only)", width=400, show=False)
    dpg.add_checkbox(tag="separate_channel", label="Separate Channel", default_value=False, show=False)
    dpg.add_button(label="Execute", callback=submit_callback, width=200)
    dpg.add_text("Result", color=(255, 255, 0))
    dpg.add_text(tag="result_text", default_value="Waiting for input...", color=(255, 255, 255))
 
dpg.set_primary_window("MainWindow", True)
dpg.show_viewport()
dpg.start_dearpygui()
 
# Save config on exit
config = configparser.ConfigParser()
if os.path.exists("config.ini"):
    config.read("config.ini")
if not config.has_section("data"):
    config.add_section("data")
try:
    config["data"]["user"] = dpg.get_value("Username")
    config["data"]["pwd"] = dpg.get_value("Password")
    config["data"]["server"] = dpg.get_value("Server")
    config["data"]["chartype"] = dpg.get_value("test type")
    config["data"]["foldername"] = dpg.get_value("Folder")
    with open("config.ini", "w") as configfile:
        config.write(configfile)
except Exception as e:
    print(f"Error saving credentials: {e}")
 
dpg.destroy_context()