mode_dark_light.py

import json
import math
import os
import platform
import re
import subprocess
import threading
import time
import tkinter
import tkinter.messagebox
import requests
import ai_assistant
from functools import partial
from tkinter import filedialog as fd
from common.constants import *
from common.cgra_param_tile import ParamTile
from common.cgra_param_spm import ParamSPM
from common.cgra_param_link import ParamLink
from common.cgra_param import CGRAParam
from common.cgra_multi_param import MultiCGRAParam
import customtkinter
from PIL import Image, ImageTk, ImageFile

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--theme")
args = parser.parse_args()
customtkinter.set_appearance_mode("dark")  # Modes: system (default), light, dark
customtkinter.set_default_color_theme("dark-blue")  # Themes: blue (default), dark-blue, green
# CANVAS_BG_COLOR = "#2B2B2B"
CANVAS_BG_COLOR = "#212121"
CANVAS_LINE_COLOR = "white"
MULTI_CGRA_FRAME_COLOR = "#14375E"
MULTI_CGRA_TILE_COLOR = "#1F538D"
MULTI_CGRA_TXT_COLOR = "white"
MULTI_CGRA_SELECTED_COLOR = "lightblue"

if args.theme:
    # print(f'Input theme argument: {args.theme}')
    if args.theme == 'light':
        customtkinter.set_appearance_mode("light")  # Modes: system (default), light, dark
        customtkinter.set_default_color_theme("dark-blue")  # Themes: blue (default), dark-blue, green
        CANVAS_BG_COLOR = "#E5E5E5"
        CANVAS_LINE_COLOR = "black"
        MULTI_CGRA_FRAME_COLOR = "#325882"
        MULTI_CGRA_TILE_COLOR = "#3A7EBF"
        MULTI_CGRA_TXT_COLOR = "black"

from VectorCGRA.cgra.test.CgraTemplateRTL_test import test_cgra_universal
from VectorCGRA.multi_cgra.test.MeshMultiCgraTemplateRTL_test import test_mesh_multi_cgra_universal, test_simplified_multi_cgra

# importing module
import logging

# Create and configure logger
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s')


def window_size(window, width, height):
    window.geometry(f"{width}x{height}")


master = customtkinter.CTk()
master.title(
    "Neura: An Integrated End-to-End Framework for Multi-CGRA Exploration, Compilation, Synthesis and Evaluation")

# Stores the UI elements that need to communicate between UI components
widgets = {}
images = {}
entireTileCheckVar = tkinter.IntVar()
mappingAlgoCheckVar = tkinter.IntVar()
fuCheckVars = {}
fuCheckbuttons = {}
xbarCheckVars = {}
xbarCheckbuttons = {}
kernelOptions = tkinter.StringVar()
kernelOptions.set("Not selected yet")
synthesisRunning = False
constraintFilePath = ""
configFilePath = ""

mapped_tile_color_list = ['#FFF113', '#75D561', '#F2CB67', '#FFAC73', '#F3993A', '#B3FF04', '#C2FFFF']

processOptions = tkinter.StringVar()
processOptions.set("asap7")


# TODO: Removes this and uses MultiCGRAParams.py
class CgraOfMultiCgra:
    def __init__(s, cgraId, xStartPos, yStartPos, tileRows, tileCols):
        s.cgraId = cgraId
        s.xStartPos = xStartPos
        s.yStartPos = yStartPos
        s.tileRows = tileRows
        s.tileCols = tileCols


class ToolTip(object):

    def __init__(self, widget):
        self.widget = widget
        self.tipwindow = None
        self.id = None
        self.x = self.y = 0

    def showtip(self, text):
        "Display text in tooltip window"
        self.text = text
        if self.tipwindow or not self.text:
            return
        x, y, cx, cy = self.widget.bbox("insert")
        x = x + self.widget.winfo_rootx() + 57
        y = y + cy + self.widget.winfo_rooty() + 27
        # self.tipwindow = tw = tkinter.Toplevel(self.widget)
        self.tipwindow = tw = customtkinter.CTkToplevel(self.widget)
        tw.wm_overrideredirect(1)
        tw.wm_geometry("+%d+%d" % (x, y))
        # label = tkinter.Label(tw, text=self.text, justify=tkinter.LEFT,
        #                       background="#ffffe0", relief=tkinter.SOLID, borderwidth=1,
        #                       font=("tahoma", "8", "normal"))
        label = customtkinter.CTkLabel(tw, text=self.text)
        label.pack(ipadx=1)

    def hidetip(self):
        tw = self.tipwindow
        self.tipwindow = None
        if tw:
            tw.destroy()


def CreateToolTip(widget, text):
    toolTip = ToolTip(widget)

    def enter(event):
        toolTip.showtip(text)

    def leave(event):
        toolTip.hidetip()

    widget.bind('<Enter>', enter)
    widget.bind('<Leave>', leave)


def clickTile(ID):
    logging.info("click Title ")
    # widgets["fuConfigPannel"].configure(text='Tile ' + str(ID) + ' functional units')
    widgets["fuConfigPannel"].configure(label_text='Tile ' + str(ID) + '\nfunctional units')
    # widgets["xbarConfigPannel"].config(text='Tile ' + str(ID) + ' crossbar outgoing links')
    widgets["xbarConfigPannel"].configure(label_text='Tile ' + str(ID) + '\ncrossbar outgoing links')
    widgets["xbarCentralTilelabel"].configure(text='Tile ' + str(ID))
    # logging.info(widgets['spmOutlinksSwitches'])
    # After clicking the tile, the pannel will fill all directions
    # widgets["xbarConfigPannel"].grid(columnspan=4, row=9, column=0, rowspan=3, sticky="nsew")
    widgets["entireTileCheckbutton"].configure(text='Disable entire Tile ' + str(ID), state="normal")
    # widgets["spmConfigPannel"].grid_forget()
    selectedCgraParam.targetTileID = ID

    disabled = selectedCgraParam.getTileOfID(ID).disabled
    for fuType in fuTypeList:
        fuCheckVars[fuType].set(selectedCgraParam.tiles[ID].fuDict[fuType])
        fuCheckbuttons[fuType].configure(state="disabled" if disabled else "normal")

    for xbarType in xbarTypeList:
        xbarCheckVars[xbarType].set(selectedCgraParam.tiles[ID].xbarDict[xbarType])
        xbarCheckbuttons[xbarType].configure(
            state="disabled" if disabled or xbarType2Port[xbarType] in selectedCgraParam.tiles[
                ID].neverUsedOutPorts else "normal")

    entireTileCheckVar.set(1 if selectedCgraParam.getTileOfID(ID).disabled else 0)


def clickSPM():
    logging.info('clickSPM')
    # widgets["fuConfigPannel"].config(text='Tile ' + str(cgraParam.targetTileID) + ' functional units')
    # widgets["fuConfigPannelLabel"].configure(text='Tile ' + str(cgraParam.targetTileID) + ' functional units')
    #
    # for fuType in fuTypeList:
    #     fuCheckVars[fuType].set(cgraParam.tiles[cgraParam.targetTileID].fuDict[fuType])
    #     fuCheckbuttons[fuType].configure(state="disabled")
    #
    # widgets["xbarConfigPannel"].grid_forget()
    #
    # spmConfigPannel = widgets["spmConfigPannel"]
    # spmConfigPannel.config(text='DataSPM outgoing links')
    # # After clicking the SPM, the pannel will fill all directions
    # spmConfigPannel.grid(row=9, column=0, rowspan=3, columnspan=4, sticky="nsew")
    #
    # spmEnabledListbox = widgets["spmEnabledListbox"]
    # spmDisabledListbox = widgets["spmDisabledListbox"]
    #
    # widgets["entireTileCheckbutton"].configure(text='Disable entire Tile ' + str(cgraParam.targetTileID), state="disabled")


def switchDataSPMOutLinks():
    spmOutlinksSwitches = widgets['spmOutlinksSwitches']
    for portIdx, switch in enumerate(spmOutlinksSwitches):
        link = selectedCgraParam.dataSPM.outLinks[portIdx]
        if switch.get():
            link.disabled = False
        else:
            link.disabled = True


# TODO : move this inside CGRAParams and trigger UI update.
def updateFunCheckVars(type, value):
    fuCheckVars[type].set(value)


def updateFunCheckoutButtons(type, updatedState):
    fuCheckbuttons[type].configure(state=updatedState)


# TODO : move this inside CGRAParams and trigger UI update.
def updateXbarCheckVars(type, value):
    xbarCheckVars[type].set(value)


def updateXbarCheckbuttons(type, updateState):
    xbarCheckbuttons[type].configure(state=updateState)


def getFunCheckVars():
    return fuCheckVars


def getXbarCheckVars():
    return xbarCheckVars


multiCgraParam = MultiCGRAParam(rows=CGRA_ROWS, cols=CGRA_COLS, globalWidgets=widgets)
multiCgraParam.setSelectedCgra(0, 0)
selectedCgraParam = multiCgraParam.getSelectedCgra()
selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                           updateFunCheckoutButtons=updateFunCheckoutButtons,
                                           updateFunCheckVars=updateFunCheckVars,
                                           updateXbarCheckbuttons=updateXbarCheckbuttons,
                                           updateXbarCheckVars=updateXbarCheckVars,
                                           getFunCheckVars=getFunCheckVars,
                                           getXbarCheckVars=getXbarCheckVars)


def apply_fu_types_to_cgra(fu_types):
    """Apply FU types to the current selectedCgraParam tiles and update UI checkboxes."""
    if not fu_types:
        return
    for tile in selectedCgraParam.tiles:
        for fuType in fuTypeList:
            tile.fuDict[fuType] = 1 if fuType in fu_types else 0
    for fuType in fuTypeList:
        if fuType in fuCheckVars:
            fuCheckVars[fuType].set(1 if fuType in fu_types else 0)


def display_ai_response(response, error):
    """Display AI response in chat (called from main thread)."""
    chatDisplay = widgets.get("chatDisplay")
    sendButton = widgets.get("sendButton")
    applyButton = widgets.get("applyConfigButton")
    if not chatDisplay:
        return

    chatDisplay.configure(state="normal")

    if error:
        chatDisplay.insert(tkinter.END, f"AI: ⚠️ {error}\n")
    else:
        chatDisplay.insert(tkinter.END, f"AI: {response}\n")

        # Check if response contains CGRA configuration
        if ai_assistant.extract_cgra_config(response):
            # Auto-apply balanced config as default
            config = ai_assistant.lastRecommendedConfigs.get("balanced", {})
            if config:
                apply_config_by_mode("balanced")
                updateMultiCgraPanelOnly(master)  # Update Multi-CGRA panel without resetting Per-CGRA entries
                clickUpdate(master)  # Update Per-CGRA panel with AI values
                # Apply FU types after clickUpdate to avoid being overwritten
                fu_types = config.get("fu_types", [])
                apply_fu_types_to_cgra(fu_types)
                chatDisplay.configure(state="normal")
                chatDisplay.insert(tkinter.END, "\n✅ Balanced configuration has been applied to update the CGRA.\n")
                chatDisplay.insert(tkinter.END, "You can also click 'Apply AI Generated CGRA Design' to switch to a different configuration mode.\n")
            if applyButton:
                applyButton.configure(state="normal")

    chatDisplay.insert(tkinter.END, "─" * 30 + "\n\n")
    chatDisplay.configure(state="disabled")
    chatDisplay.see(tkinter.END)

    # Re-enable send button
    if sendButton:
        sendButton.configure(state="normal")


def clickSendChat():
    """Handle sending a chat message."""
    chatInput = widgets.get("chatInput")
    chatDisplay = widgets.get("chatDisplay")
    sendButton = widgets.get("sendButton")
    if not chatInput or not chatDisplay:
        return

    user_message = chatInput.get().strip()
    if not user_message:
        return

    # Clear input and disable send button
    chatInput.delete(0, tkinter.END)
    if sendButton:
        sendButton.configure(state="disabled")

    # Display user message
    chatDisplay.configure(state="normal")
    chatDisplay.insert(tkinter.END, f"You: {user_message}\n")
    chatDisplay.insert(tkinter.END, "─" * 30 + "\n")
    chatDisplay.insert(tkinter.END, "AI: Thinking...\n")
    chatDisplay.configure(state="disabled")
    chatDisplay.see(tkinter.END)

    # Call API in background thread
    def on_response(response, error):
        # Schedule UI update on main thread
        chatDisplay.after(0, lambda: update_response(response, error))

    def update_response(response, error):
        chatDisplay.configure(state="normal")
        # Remove "Thinking..." line
        chatDisplay.delete("end-2l", "end-1l")
        chatDisplay.configure(state="disabled")
        display_ai_response(response, error)

    thread = threading.Thread(target=ai_assistant.call_ai_api, args=(user_message, on_response))
    thread.daemon = True
    thread.start()


def clickClearChat():
    """Clear the chat history."""
    chatDisplay = widgets.get("chatDisplay")
    if chatDisplay:
        chatDisplay.configure(state="normal")
        chatDisplay.delete("1.0", tkinter.END)
        chatDisplay.configure(state="disabled")
    # Also clear conversation history
    ai_assistant.aiChatConfig["chat_history"] = []


def handle_chat_enter(event):
    """Handle Enter key press in chat input."""
    clickSendChat()
    return "break"  # Prevent default behavior


def on_provider_change(choice):
    """Handle provider selection change."""
    ai_assistant.aiChatConfig["provider"] = choice
    ai_assistant.aiChatConfig["chat_history"] = []  # Clear history when switching provider

    # Update model menu with provider's models
    provider_config = ai_assistant.AI_PROVIDERS[choice]
    models = provider_config["models"]
    ai_assistant.aiChatConfig["model"] = models[0]

    modelMenu = widgets.get("modelMenu")
    if modelMenu:
        modelMenu.configure(values=models)
        modelMenu.set(models[0])

    # Update API key from environment
    env_key = provider_config["env_key"]
    env_value = os.environ.get(env_key, "")
    ai_assistant.aiChatConfig["api_key"] = env_value

    apiKeyEntry = widgets.get("apiKeyEntry")
    if apiKeyEntry:
        apiKeyEntry.delete(0, tkinter.END)
        if env_value:
            apiKeyEntry.insert(0, env_value)

    logging.info(f"AI provider changed to: {choice}")


def on_model_change(choice):
    """Handle model selection change."""
    ai_assistant.aiChatConfig["model"] = choice
    logging.info(f"AI model changed to: {choice}")


def on_api_key_change(event=None):
    """Handle API key input change."""
    apiKeyEntry = widgets.get("apiKeyEntry")
    if apiKeyEntry:
        ai_assistant.aiChatConfig["api_key"] = apiKeyEntry.get().strip()


def apply_config_by_mode(mode):
    """Apply the specified mode configuration to the GUI."""

    config = ai_assistant.lastRecommendedConfigs.get(mode, {})
    if not config:
        return False

    try:
        # Get configuration values (already validated)
        rows = config.get("cgra_rows", 4)
        columns = config.get("cgra_columns", 4)
        data_mem = config.get("data_spm_kb", 8)
        config_mem = config.get("configMemSize", 64)
        mc_rows = config.get("multi_cgra_rows", 1)
        mc_cols = config.get("multi_cgra_columns", 1)

        # Update CGRA config entries
        rowsEntry = widgets.get("rowsEntry")
        columnsEntry = widgets.get("columnsEntry")
        dataMemEntry = widgets.get("dataMemEntry")
        configMemEntry = widgets.get("configMemEntry")

        if rowsEntry:
            rowsEntry.delete(0, tkinter.END)
            rowsEntry.insert(0, str(rows))
        if columnsEntry:
            columnsEntry.delete(0, tkinter.END)
            columnsEntry.insert(0, str(columns))
        if dataMemEntry:
            dataMemEntry.delete(0, tkinter.END)
            dataMemEntry.insert(0, str(data_mem))
        if configMemEntry:
            configMemEntry.delete(0, tkinter.END)
            configMemEntry.insert(0, str(config_mem))

        # Update Multi-CGRA config entries if available
        mcRowsEntry = widgets.get("multiCgraRowsLabelEntry")
        mcColsEntry = widgets.get("multiCgraColumnsEntry")
        if mcRowsEntry:
            mcRowsEntry.delete(0, tkinter.END)
            mcRowsEntry.insert(0, str(mc_rows))
        if mcColsEntry:
            mcColsEntry.delete(0, tkinter.END)
            mcColsEntry.insert(0, str(mc_cols))

        # Apply FU types to all tiles if specified
        fu_types = config.get("fu_types", [])
        fu_applied = False
        if fu_types:
            apply_fu_types_to_cgra(fu_types)
            fu_applied = True

        # Show success message
        mode_labels = {"high_performance": "High Performance", "balanced": "Balanced", "low_power": "Low Power"}
        mode_label = mode_labels.get(mode, mode)
        chatDisplay = widgets.get("chatDisplay")
        if chatDisplay:
            chatDisplay.configure(state="normal")
            chatDisplay.insert(tkinter.END, f"✓ {mode_label} Config Applied:\n")
            chatDisplay.insert(tkinter.END, f"  CGRA: {rows}x{columns}\n")
            chatDisplay.insert(tkinter.END, f"  Multi-CGRA: {mc_rows}x{mc_cols}\n")
            chatDisplay.insert(tkinter.END, f"  Data SPM: {data_mem} KB\n")
            chatDisplay.insert(tkinter.END, f"  Config Memory: {config_mem} entries\n")
            if fu_applied:
                chatDisplay.insert(tkinter.END, f"  FU Types: {', '.join(fu_types)}\n")
            chatDisplay.insert(tkinter.END, "─" * 30 + "\n")
            chatDisplay.configure(state="disabled")
            chatDisplay.see(tkinter.END)

        logging.info(f"Applied {mode} config: rows={rows}, cols={columns}")
        return True

    except Exception as e:
        logging.error(f"Failed to apply config: {e}")
        return False


def apply_recommended_config():
    """Show dialog to choose between high_performance, balanced, and low power config."""

    has_perf = bool(ai_assistant.lastRecommendedConfigs.get("high_performance"))
    has_bal = bool(ai_assistant.lastRecommendedConfigs.get("balanced"))
    has_lp = bool(ai_assistant.lastRecommendedConfigs.get("low_power"))

    if not has_perf and not has_bal and not has_lp:
        tkinter.messagebox.showwarning("No Configuration",
            "No recommended configuration available.\nAsk AI to recommend parameters first.")
        return

    # Create selection dialog
    dialog = customtkinter.CTkToplevel()
    dialog.title("Select Configuration Mode")
    dialog.geometry("450x180")
    dialog.transient()
    # dialog.grab_set()
    dialog.update_idletasks()
    try:
        dialog.grab_set()
    except Exception as e:
        print(f"Warning: Cannot set grab on dialog: {e}")
        
    label = customtkinter.CTkLabel(
        dialog,
        text="Choose configuration mode:",
        font=customtkinter.CTkFont(size=14, weight="bold")
    )
    label.pack(pady=(15, 10))

    btn_frame = customtkinter.CTkFrame(dialog)
    btn_frame.pack(pady=10, padx=15, fill="x")

    def apply_and_update(mode):
        dialog.destroy()
        apply_config_by_mode(mode)
        updateMultiCgraPanelOnly(master)  # Update Multi-CGRA panel without resetting Per-CGRA entries
        clickUpdate(master)  # Update Per-CGRA panel with AI values
        fu_types = ai_assistant.lastRecommendedConfigs.get(mode, {}).get("fu_types", [])
        apply_fu_types_to_cgra(fu_types)

    def apply_perf():
        apply_and_update("high_performance")

    def apply_bal():
        apply_and_update("balanced")

    def apply_lp():
        apply_and_update("low_power")

    # Performance button
    perf_btn = customtkinter.CTkButton(
        btn_frame,
        text="High Performance",
        command=apply_perf,
        state="normal" if has_perf else "disabled",
        fg_color="#1565C0",
        hover_color="#0D47A1",
        height=40
    )
    perf_btn.pack(side="left", padx=3, expand=True, fill="x")

    # Balanced button
    bal_btn = customtkinter.CTkButton(
        btn_frame,
        text="Balanced",
        command=apply_bal,
        state="normal" if has_bal else "disabled",
        fg_color="#F57C00",
        hover_color="#E65100",
        height=40
    )
    bal_btn.pack(side="left", padx=3, expand=True, fill="x")

    # Low Power button
    lp_btn = customtkinter.CTkButton(
        btn_frame,
        text="Low Power",
        command=apply_lp,
        state="normal" if has_lp else "disabled",
        fg_color="#2E7D32",
        hover_color="#1B5E20",
        height=40
    )
    lp_btn.pack(side="left", padx=3, expand=True, fill="x")

    # Cancel button
    cancel_btn = customtkinter.CTkButton(
        dialog,
        text="Cancel",
        command=dialog.destroy,
        width=80
    )
    cancel_btn.pack(pady=10)


def clickAutoConfig():
    """Send auto-configuration request to AI."""
    chatInput = widgets.get("chatInput")
    chatDisplay = widgets.get("chatDisplay")

    if not chatInput or not chatDisplay:
        return

    # Show prompt dialog for application description
    dialog = customtkinter.CTkInputDialog(
        text="Describe your application/kernel:\n(e.g., 'matrix multiplication', 'convolution for CNN', 'FFT processing')",
        title="Auto Configure CGRA"
    )
    user_input = dialog.get_input()

    if not user_input or not user_input.strip():
        return

    # Create the auto-config request message
    auto_config_prompt = f"Please recommend optimal CGRA parameters for: {user_input.strip()}"

    # Insert the prompt into chat input and send
    chatInput.delete(0, tkinter.END)
    chatInput.insert(0, auto_config_prompt)
    clickSendChat()


def clickAIAnalyzeCurrentState():
    """Analyze current kernel/mapping state and send to AI for recommendations."""
    chatDisplay = widgets.get("chatDisplay")
    if not chatDisplay:
        return

    # Check if mapping has been done
    map_ii_entry = widgets.get("mapIIEntry")
    has_mapping = map_ii_entry and map_ii_entry.get() and map_ii_entry.get().strip() != ""

    if not has_mapping or selectedCgraParam.DFGNodeCount <= 0:
        tkinter.messagebox.showinfo(
            "Mapping Required",
            " Please first enter a kernel and complete the compilation and mapping work in the Kernel panel.\n"
            "Then click this button again for AI analysis."
        )
        return

    # Gather mapping results
    current_rows = widgets.get("rowsEntry").get() if widgets.get("rowsEntry") else "4"
    current_cols = widgets.get("columnsEntry").get() if widgets.get("columnsEntry") else "4"
    config_mem = widgets.get("configMemEntry").get() if widgets.get("configMemEntry") else "64"
    data_mem = widgets.get("dataMemEntry").get() if widgets.get("dataMemEntry") else "8"

    kernel_name = selectedCgraParam.targetKernelName or "unknown"
    dfg_nodes = selectedCgraParam.DFGNodeCount
    rec_mii = widgets.get("recMIIEntry").get() if widgets.get("recMIIEntry") else "0"
    res_mii = widgets.get("resMIIEntry").get() if widgets.get("resMIIEntry") else "0"
    map_ii = map_ii_entry.get()

    try:
        speedup = dfg_nodes / int(map_ii)
    except:
        speedup = 0

    # Build prompt for AI
    analyze_prompt = f"""Based on the following CGRA mapping results, analyze and recommend a better configuration:

## Current Configuration
- CGRA Size: {current_rows}x{current_cols}
- Config Memory: {config_mem}
- Data SPM: {data_mem} KB

## Mapping Results
- Kernel: {kernel_name}
- DFG Node Count: {dfg_nodes}
- RecMII (recurrence): {rec_mii}
- ResMII (resource): {res_mii}
- Mapping II (actual): {map_ii}
- Speedup: {speedup:.2f}x

## Analysis Required
1. Is Mapping II close to the theoretical optimum (RecMII/ResMII)?
2. If there's a gap, what might be the bottleneck?
3. What configuration would improve high_performance?

Please provide specific CGRA parameter recommendations."""

    # Show in chat
    chatDisplay.configure(state="normal")
    chatDisplay.insert(tkinter.END, f"You: Analyze {kernel_name} mapping\n")
    chatDisplay.insert(tkinter.END, f"  CGRA: {current_rows}x{current_cols}, ")
    chatDisplay.insert(tkinter.END, f"DFG: {dfg_nodes} nodes\n")
    chatDisplay.insert(tkinter.END, f"  II: {map_ii} (Rec:{rec_mii}, Res:{res_mii})\n")
    chatDisplay.insert(tkinter.END, "─" * 30 + "\n")
    chatDisplay.configure(state="disabled")
    chatDisplay.see(tkinter.END)

    # Send to AI
    def on_response(response, error):
        chatDisplay.configure(state="normal")
        if error:
            chatDisplay.insert(tkinter.END, f"Error: {error}\n")
        else:
            chatDisplay.insert(tkinter.END, f"AI: {response}\n")
            if ai_assistant.extract_cgra_config(response):
                widgets["applyConfigButton"].configure(state="normal")
        chatDisplay.insert(tkinter.END, "─" * 30 + "\n\n")
        chatDisplay.configure(state="disabled")
        chatDisplay.see(tkinter.END)

    import threading
    thread = threading.Thread(target=lambda: ai_assistant.call_ai_api(analyze_prompt, on_response))
    thread.daemon = True
    thread.start()


def clickSPMPortDisable():
    spmEnabledListbox = widgets["spmEnabledListbox"]
    portIndex = spmEnabledListbox.curselection()
    if portIndex:
        port = spmEnabledListbox.get(portIndex)
        spmEnabledListbox.delete(portIndex)
        widgets["spmDisabledListbox"].insert(0, port)

        link = selectedCgraParam.dataSPM.outLinks[port]
        link.disabled = True


def clickSPMPortEnable():
    spmDisabledListbox = widgets["spmDisabledListbox"]
    portIndex = spmDisabledListbox.curselection()
    if portIndex:
        port = spmDisabledListbox.get(portIndex)
        spmDisabledListbox.delete(portIndex)

        widgets["spmEnabledListbox"].insert(0, port)

        link = selectedCgraParam.dataSPM.outLinks[port]
        link.disabled = False


def clickEntireTileCheckbutton():
    if entireTileCheckVar.get() == 1:

        for fuType in fuTypeList:
            fuCheckVars[fuType].set(0)
            tile = selectedCgraParam.getTileOfID(selectedCgraParam.targetTileID)
            tile.fuDict[fuType] = 0
            # clickFuCheckbutton(fuType)
            fuCheckbuttons[fuType].configure(state="disabled")

        selectedCgraParam.getTileOfID(selectedCgraParam.targetTileID).disabled = True
    else:
        for fuType in fuTypeList:
            fuCheckVars[fuType].set(0)
            tile = selectedCgraParam.getTileOfID(selectedCgraParam.targetTileID)
            tile.fuDict[fuType] = 0
            # clickFuCheckbutton(fuType)
            fuCheckbuttons[fuType].configure(state="normal")

        # cgraParam.getTileOfID(cgraParam.targetTileID).disabled = False


def clickFuCheckbutton(fuType):
    selectedCgraParam.updateFuCheckbutton(fuType, fuCheckVars[fuType].get())


def clickXbarCheckbutton(xbarType):
    selectedCgraParam.updateXbarCheckbutton(xbarType, xbarCheckVars[xbarType].get())


def clickUpdate(root):
    rows = int(widgets["rowsEntry"].get())
    columns = int(widgets["columnsEntry"].get())
    configMemSize = int(widgets["configMemEntry"].get())
    dataMemSize = int(widgets["dataMemEntry"].get())

    global selectedCgraParam
    oldCGRA = selectedCgraParam

    old_rows_num = selectedCgraParam.rows
    if selectedCgraParam.rows != rows or selectedCgraParam.columns != columns:
        selectedCgraParam = CGRAParam(rows, columns, CONFIG_MEM_SIZE, DATA_MEM_SIZE, widgets)
        selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                                   updateFunCheckoutButtons=updateFunCheckoutButtons,
                                                   updateFunCheckVars=updateFunCheckVars,
                                                   updateXbarCheckbuttons=updateXbarCheckbuttons,
                                                   updateXbarCheckVars=updateXbarCheckVars,
                                                   getFunCheckVars=getFunCheckVars,
                                                   getXbarCheckVars=getXbarCheckVars)

    multiCgraParam.cgras[multiCgraParam.selected_row][multiCgraParam.selected_col] = selectedCgraParam

    # dataSPM = ParamSPM(MEM_WIDTH, rows, rows)
    # cgraParam.initDataSPM(dataSPM)

    create_cgra_pannel(root, rows, columns)

    # kernel related information and be kept to avoid redundant compilation
    selectedCgraParam.updateMemSize(configMemSize, dataMemSize)
    selectedCgraParam.updateTiles()
    selectedCgraParam.updateLinks()
    if old_rows_num != rows:
        selectedCgraParam.updateSpmOutlinks()

    selectedCgraParam.targetAppName = oldCGRA.targetAppName
    selectedCgraParam.compilationDone = oldCGRA.compilationDone
    selectedCgraParam.targetKernels = oldCGRA.targetKernels
    selectedCgraParam.targetKernelName = oldCGRA.targetKernelName
    selectedCgraParam.DFGNodeCount = oldCGRA.DFGNodeCount
    selectedCgraParam.recMII = oldCGRA.recMII
    selectedCgraParam.verilogDone = False

    widgets["verilogText"].delete("1.0", tkinter.END)
    widgets["resMIIEntry"].delete(0, tkinter.END)
    if len(selectedCgraParam.getValidTiles()) > 0 and selectedCgraParam.DFGNodeCount > 0:
        selectedCgraParam.resMII = math.ceil(
            (selectedCgraParam.DFGNodeCount + 0.0) / len(selectedCgraParam.getValidTiles())) // 1
        widgets["resMIIEntry"].insert(0, selectedCgraParam.resMII)
    else:
        widgets["resMIIEntry"].insert(0, 0)


def clickReset(root):
    rows = int(widgets["rowsEntry"].get())
    columns = int(widgets["columnsEntry"].get())
    configMemSize = int(widgets["configMemEntry"].get())
    dataMemSize = int(widgets["dataMemEntry"].get())

    global selectedCgraParam
    oldCGRA = selectedCgraParam

    if selectedCgraParam.rows != rows or selectedCgraParam.columns != columns:
        selectedCgraParam = CGRAParam(rows, columns, CONFIG_MEM_SIZE, DATA_MEM_SIZE, widgets)
        selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                                   updateFunCheckoutButtons=updateFunCheckoutButtons,
                                                   updateFunCheckVars=updateFunCheckVars,
                                                   updateXbarCheckbuttons=updateXbarCheckbuttons,
                                                   updateXbarCheckVars=updateXbarCheckVars,
                                                   getFunCheckVars=getFunCheckVars,
                                                   getXbarCheckVars=getXbarCheckVars)

    selectedCgraParam.updateMemSize(configMemSize, dataMemSize)
    selectedCgraParam.resetTiles()
    selectedCgraParam.enableAllTemplateLinks()
    selectedCgraParam.resetLinks()

    selectedCgraParam.updateSpmOutlinks()

    create_cgra_pannel(root, rows, columns)

    # for _ in range(cgraParam.rows):
    #     widgets["spmEnabledListbox"].delete(0)
    #     widgets["spmDisabledListbox"].delete(0)

    # widgets['spmOutlinksSwitches'] = []
    # spmOutlinksSwitches = []
    # spmConfigPannel = widgets["spmConfigPannel"]
    # for port in cgraParam.dataSPM.outLinks:
    #     switch = customtkinter.CTkSwitch(spmConfigPannel, text=f"link {port}", command=switchDataSPMOutLinks)
    #     if not cgraParam.dataSPM.outLinks[port].disabled:
    #         switch.select()
    #     switch.pack(pady=(5, 10))
    #     spmOutlinksSwitches.insert(0, switch)
    # widgets['spmOutlinksSwitches'] = spmOutlinksSwitches

    # kernel related information and be kept to avoid redundant compilation
    selectedCgraParam.targetAppName = oldCGRA.targetAppName
    selectedCgraParam.compilationDone = oldCGRA.compilationDone
    selectedCgraParam.targetKernels = oldCGRA.targetKernels
    selectedCgraParam.targetKernelName = oldCGRA.targetKernelName
    selectedCgraParam.DFGNodeCount = oldCGRA.DFGNodeCount
    selectedCgraParam.recMII = oldCGRA.recMII

    widgets["verilogText"].delete(0, tkinter.END)
    widgets["resMIIEntry"].delete(0, tkinter.END)
    if len(selectedCgraParam.getValidTiles()) > 0 and selectedCgraParam.DFGNodeCount > 0:
        selectedCgraParam.resMII = math.ceil(
            (selectedCgraParam.DFGNodeCount + 0.0) / len(selectedCgraParam.getValidTiles())) // 1
        widgets["resMIIEntry"].insert(0, selectedCgraParam.resMII)
    else:
        widgets["resMIIEntry"].insert(0, 0)

# Customizes class to force flow style dump.
class FlowList(list):
    pass


import yaml
def flow_list_representer(dumper, data):
    return dumper.represent_sequence('tag:yaml.org,2002:seq', data, flow_style=True)
# Forces dumping the FlowList in the flow style.
yaml.add_representer(FlowList, flow_list_representer)

def dumpArchYaml(yamlPath = 'arch.yaml'):
    """
    Dumps the architecture to a YAML file.
    The default path is `build/arch.yaml`.
    """
    # Extract values from widgets
    # Multi-CGRA Defaults
    topo = widgets["topologyVariable"].get() if "topologyVariable" in widgets else "mesh"
    mc_rows_str = widgets["multiCgraRowsLabelEntry"].get()
    mc_rows = int(mc_rows_str)
    mc_cols_str = widgets["multiCgraColumnsEntry"].get()
    mc_cols = int(mc_cols_str)
    mem_cap_str = widgets["totalSRAMSizeLabelEntry"].get()
    mem_cap = int(mem_cap_str)
    data_bw_str = widgets["dataBitwidthEntry"].get()
    data_bw = int(data_bw_str)
    vec_lanes_str = widgets["vectorLanesEntry"].get()
    vec_lanes = int(vec_lanes_str)

    # CGRA Defaults
    cgra_rows_str = widgets["rowsEntry"].get()
    cgra_rows = int(cgra_rows_str)
    cgra_cols_str = widgets["columnsEntry"].get()
    cgra_cols = int(cgra_cols_str)
    
    cfg_mem_str = widgets["configMemEntry"].get()
    cfg_mem = int(cfg_mem_str)
    sram_str = widgets["dataMemEntry"].get()
    sram = int(sram_str)

    data = {
        "architecture": {
            "name": "NeuraMultiCgra",
            "version": "1.0"
        },
        "multi_cgra_defaults": {
            "base_topology": topo,
            "rows": mc_rows,
            "columns": mc_cols,
            "memory": {
                "capacity": mem_cap,
                "data bitwidth": data_bw,
                "vector lanes": vec_lanes
            }
        },
        "cgra_defaults": {
            "rows": cgra_rows,
            "columns": cgra_cols,
            "configMemSize": cfg_mem,
            "per bank sram": sram
        },
        "tile_defaults": {
            "num_registers": 16,
            "fu_types": FlowList(fuTypeList)
        }
    }

    # Collects the links information.
    link_overrides = []
    for r in range(multiCgraParam.rows):
        for c in range(multiCgraParam.cols):
            target_cgra = multiCgraParam.getCgraParam(r, c)
            # Checks all template links in the CGRA.
            for link in target_cgra.templateLinks:
                if link.disabled:
                    if isinstance(link.srcTile, ParamTile) and isinstance(link.dstTile, ParamTile):
                        link_overrides.append({
                            "src_cgra_x": c,
                            "src_cgra_y": r,
                            "dst_cgra_x": c,
                            "dst_cgra_y": r,
                            "src_tile_x": link.srcTile.dimX,
                            "src_tile_y": link.srcTile.dimY,
                            "dst_tile_x": link.dstTile.dimX,
                            "dst_tile_y": link.dstTile.dimY,
                            "existence": False
                        })

    if link_overrides:
        data["link_overrides"] = link_overrides

    # Collects the tile information.
    tile_overrides = []
    for r in range(multiCgraParam.rows):
        for c in range(multiCgraParam.cols):
            target_cgra = multiCgraParam.getCgraParam(r, c)
            for tile in target_cgra.tiles:
                # Case 1: Tile is totally disabled.
                if tile.disabled:
                    tile_overrides.append({
                        "cgra_x": c,
                        "cgra_y": r,
                        "tile_x": tile.dimX,
                        "tile_y": tile.dimY,
                        "existence": False
                    })
                # Case 2: Tile is enabled but has non-default functional units.
                elif not tile.isDefaultFus():
                    fuTypes = []
                    for fu in fuTypeList:
                        if tile.fuDict[fu] == 1:
                            fuTypes.append(fu)
                    tile_overrides.append({
                        "cgra_x": c,
                        "cgra_y": r,
                        "tile_x": tile.dimX,
                        "tile_y": tile.dimY,
                        "fu_types": FlowList(fuTypes),
                        "existence": True
                    })

    if tile_overrides:
        data["tile_overrides"] = tile_overrides

    with open(yamlPath, 'w') as file:
        yaml.dump(data, file, sort_keys=False, default_flow_style=False)
        
    logging.info(f"Successfully dumped architecture config to {yamlPath}")
    

def clickTest():
    # Dumps the architecture to `build/arch.yaml`.
    dumpArchYaml('arch.yaml')
    # need to provide the paths for lib.so and kernel.bc
    os.system("mkdir test")
    # os.system("cd test")
    os.chdir("test")

    widgets["testShow"].configure(text="0%")
    widgets["testProgress"].set(0)
    master.update_idletasks()

    pytest_cmd = pytest_cmd = "pytest ../../VectorCGRA/cgra/test \
                                ../../VectorCGRA/multi_cgra/test/MeshMultiCgraTemplateRTL_test.py --tb=short -v"
    
    testProc = subprocess.Popen(
        pytest_cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        shell=True,
        universal_newlines=True,
        bufsize=1,
        env={**os.environ, 'PYTHONUNBUFFERED': '1'}
    )
    
    failed = 0
    total = 0
    last_progress = 0
    
    # Regex pattern to match pytest progress: [ 12%] or [12%] or [100%]
    progress_pattern = re.compile(r'\[\s*(\d+)\s*%\]')
    
    try:
        for line in iter(testProc.stdout.readline, ''):
            if not line:
                break
                
            outputLine = line.rstrip()
            logging.info(outputLine)
            
            # Checks for progress percentage using regex.
            match = progress_pattern.search(outputLine)
            if match:
                try:
                    value = int(match.group(1))
                    if value != last_progress:
                        widgets["testProgress"].set(value / 100.0)
                        widgets["testShow"].configure(text=f"{value}%")
                        master.update_idletasks()
                        last_progress = value
                    total += 1
                except (ValueError, AttributeError) as e:
                    logging.warning(f"Failed to parse progress from line: {outputLine}, error: {e}")
            
            # Checks for test failures.
            if ".py" in outputLine and ("FAILED" in outputLine or "ERROR" in outputLine or " F " in outputLine):
                failed += 1
                logging.warning(f"Test failure detected: {outputLine}")
        
        # Waits for process to complete.
        testProc.wait()
        
        # Final status updates.
        if testProc.returncode == 0:
            widgets["testShow"].configure(text=" PASSED ")
        else:
            widgets["testShow"].configure(text=f" FAILED ({failed} failures)" if failed > 0 else " FAILED")
            
    except Exception as e:
        logging.error(f"Error reading pytest output: {e}")
        widgets["testShow"].configure(text=" ERROR ")
    finally:
        # Ensures the process is terminated.
        if testProc.poll() is None:
            testProc.terminate()
            testProc.wait()

    os.chdir("..")


def dumpSelectedCgraParam(yaml_path = "build/arch_selected_cgra.yaml"):
    """
    Dumps the selected CGRA parameter to a YAML file.
    """
    global selectedCgraParam
    data = {
        "multi_cgra_defaults": {
            "rows": 1,
            "columns": 1
        },
        "cgra_defaults": {
            "rows": selectedCgraParam.rows,
            "columns": selectedCgraParam.columns,
            "configMemSize": selectedCgraParam.configMemSize
        },
        "tile_defaults": {
            "num_registers": 16,
            "fu_types": FlowList(fuTypeList)
        },
        "link_overrides": [],
        "tile_overrides": []
    }
    yaml_path = os.path.join(os.path.dirname(__file__), "build/arch_selected_cgra.yaml")
    with open(yaml_path, "w") as file:
        yaml.dump(data, file, sort_keys=False, default_flow_style=False)
    logging.info(f"Successfully dumped selected CGRA parameter to {yaml_path}")

def clickGenerateVerilog():
    message = selectedCgraParam.getErrorMessage()
    if message != "":
        tkinter.messagebox.showerror(title="CGRA Model Checking", message=message)
        return

    dumpArchYaml('arch.yaml')
    arch_file_path = os.path.join(os.getcwd(), './arch.yaml')
    os.system("rm -r verilog")
    os.system("mkdir verilog")
    os.chdir("verilog")

    # pymtl function that is used to generate synthesizable verilog
    cmdline_opts = {'test_verilog': 'zeros', 'test_yosys_verilog': '', 'dump_textwave': False, 'dump_vcd': False,
                    'dump_vtb': False, 'max_cycles': None}
    # Generate 2x2 single CGRA SVerilog for synthesize and layout
    # test_cgra_universal(cmdline_opts)
    
    # Generate 2x2 2x2 CGRA Sverilog for SVerilog text area
    print(f"⏳ Generating verilog...")
    test_mesh_multi_cgra_universal(cmdline_opts, arch_file_path)
    test_simplified_multi_cgra(cmdline_opts, arch_file_path)
    os.system("cp CgraTemplateRTL__provided__pickled.v design.v")

    widgets["verilogText"].delete("1.0", tkinter.END)
    found = False
    logging.info(f"Current directory: {os.getcwd()}")
    logging.info(os.listdir("./"))
    for fileName in os.listdir("./"):
        if "MeshMultiCgraTemplateRTL__" in fileName and ".v" in fileName:
            logging.info(f"Found the file: {fileName}")
            f = open(fileName, "r")
            widgets["verilogText"].insert("1.0", f.read())
            found = True
            break

    selectedCgraParam.verilogDone = True
    if not found:
        selectedCgraParam.verilogDone = False
        widgets["verilogText"].insert(tkinter.END, "Error exists during Verilog generation")

    # os.system("mv CgraTemplateRTL__*.v design.v")
    # os.system("rename s/\.v/\.log/g *")

    os.chdir("..")


def setReportProgress(value):
    # widgets["reportProgress"].configure(value=value)
    widgets["reportProgress"].set(value / 100)


def countSynthesisTime():
    global synthesisRunning
    timeCost = 0.0
    while synthesisRunning:
        time.sleep(0.1)
        widgets["synthesisTimeEntry"].delete(0, tkinter.END)
        widgets["synthesisTimeEntry"].insert(0, round(timeCost, 1))
        timeCost += 0.1


def runYosys():
    global synthesisRunning
    os.system("make 3")

    statsFile = open("3-open-yosys-synthesis/stats.txt", 'r')
    statsLines = statsFile.readlines()

    tileArea = 0.0
    for line in statsLines:
        if "Chip area for module " in line:
            tileArea = round(float(line.split(": ")[1]) / 1000000, 2)
            break

    statsFile.close()

    widgets["reportTileAreaData"].delete(0, tkinter.END)
    widgets["reportTileAreaData"].insert(0, tileArea)

    widgets["reportTilePowerData"].delete(0, tkinter.END)
    widgets["reportTilePowerData"].insert(0, "-")

    # widgets["reportProgress"].configure(value=100)
    widgets["reportProgress"].set(1)

    os.chdir("../../../build")

    synthesisRunning = False


def clickSynthesize():
    dumpArchYaml('customized_arch.yaml')
    global selectedCgraParam
    global synthesisRunning

    if synthesisRunning:
        return

    # if not selectedCgraParam.verilogDone:
    #     tkinter.messagebox.showerror(title="Sythesis", message="The verilog generation needs to be done first.")
    #     return

    synthesisRunning = True
    synthesisTimerRun = threading.Thread(target=countSynthesisTime)
    synthesisTimerRun.start()

    os.system("mkdir -p verilog")
    os.chdir("verilog")

    # Cacti SPM power/area estimation:
    sizePattern = "[SPM_SIZE]"
    readPortPattern = "[READ_PORT_COUNT]"
    writePortPattern = "[WRITE_PORT_COUNT]"

    updatedSizePattern = str(selectedCgraParam.dataMemSize * 1024)
    updatedReadPortPattern = str(selectedCgraParam.dataSPM.getNumOfValidReadPorts())
    updatedWritePortPattern = str(selectedCgraParam.dataSPM.getNumOfValidWritePorts())

    # print current directory
    logging.info(f"Current directory: {os.getcwd()}")
    with open(r'../../tools/cacti/spm_template.cfg', 'r') as file:
        data = file.read()

        data = data.replace(sizePattern, updatedSizePattern)
        data = data.replace(readPortPattern, updatedReadPortPattern)
        data = data.replace(writePortPattern, updatedWritePortPattern)

    with open(r'../../tools/cacti/spm_temp.cfg', 'w') as file:
        file.write(data)

    os.chdir("../../tools/cacti")

    cactiCommand = "./cacti -infile spm_temp.cfg"
    cactiProc = subprocess.Popen([cactiCommand, '-u'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True,
                                 bufsize=1)
    (out, err) = cactiProc.communicate()
    success = False
    line = out.decode("ISO-8859-1")

    if "Power Components:" in line:
        success = True
        strSPMPower = line.split("Data array: Total dynamic read energy/access  (nJ): ")[1].split("\n")[0]
        strSPMTiming = line.split("Data side (with Output driver) (ns): ")[1].split("\n")[0]
        spmPower = float(strSPMPower) / float(strSPMTiming) * 1000

        widgets["reportSPMPowerData"].delete(0, tkinter.END)
        widgets["reportSPMPowerData"].insert(0, str(spmPower))

        strSPMArea = line.split("Data array: Area (mm2): ")[1].split("\n")[0]
        spmArea = float(strSPMArea)

        widgets["reportSPMAreaData"].delete(0, tkinter.END)
        widgets["reportSPMAreaData"].insert(0, str(spmArea))


    else:
        tkinter.messagebox.showerror(title="Sythesis", message="Execution of Cacti failed.")

    progress = threading.Thread(target=setReportProgress, args=[20])
    progress.start()

    os.chdir("../../build/verilog")
    # mflowgen synthesis:
    os.system("../../tools/sv2v/bin/sv2v design.v > design_sv2v.v")
    progress = threading.Thread(target=setReportProgress, args=[40])
    progress.start()

    os.system("sed -i 's/CgraTemplateRTL__.*/CgraTemplateRTL (/g' design_sv2v.v")
    progress = threading.Thread(target=setReportProgress, args=[50])
    progress.start()

    # os.system("mv design.v ../../mflowgen1/designs/cgra/rtl/outputs/design.v")
    os.system("cp design_sv2v.v ../../tools/mflowgen/designs/cgra/rtl/outputs/design.v")
    os.chdir("../../tools/mflowgen")
    os.system("mkdir ./build")
    os.chdir("./build")
    os.system("rm -r ./*")
    os.system("mflowgen run --design ../designs/cgra")

    os.system("make 2")
    progress = threading.Thread(target=setReportProgress, args=[70])
    progress.start()

    yosysRun = threading.Thread(target=runYosys)
    yosysRun.start()


def clickSelectApp(event):
    global selectedCgraParam
    selectedCgraParam.compilationDone = False
    appName = fd.askopenfilename(title="choose an application", initialdir="../", filetypes=(
        ("C/C++ file", "*.cpp"), ("C/C++ file", "*.c"), ("C/C++ file", "*.C"), ("C/C++ file", "*.CPP")))
    selectedCgraParam.targetAppName = appName

    # widgets["appPathEntry"].configure(state="normal")
    widgets["appPathEntry"].delete(0, tkinter.END)
    widgets["appPathEntry"].insert(0, selectedCgraParam.targetAppName)
    # widgets["appPathEntry"].configure(state="disabled")

    widgets["compileAppShow"].configure(text="IDLE")


def clickCompileApp():
    global selectedCgraParam
    fileName = selectedCgraParam.targetAppName
    if not fileName or fileName == "   Not selected yet":
        return

    os.system("mkdir kernel")
    os.chdir("kernel")

    compileCommand = "clang-12 -emit-llvm -fno-unroll-loops -O3 -o kernel.bc -c " + fileName
    compileProc = subprocess.Popen([compileCommand, '-u'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    (compileOut, compileErr) = compileProc.communicate()

    disassembleCommand = "llvm-dis-12 kernel.bc -o kernel.ll"
    disassembleProc = subprocess.Popen([disassembleCommand, '-u'], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                       shell=True)
    (disassembleOut, disassembleErr) = disassembleProc.communicate()

    if compileErr:
        widgets["compileAppShow"].configure(text=u'\u2717\u2717\u2717')
        os.chdir("..")
        logging.info(f"Compile error message: {compileErr}")
        return
    if disassembleErr:
        widgets["compileAppShow"].configure(text=u'\u2717\u2717\u2717')
        os.chdir("..")
        logging.info(f"Disassemble error message: {disassembleErr}")
        return

    widgets["compileAppShow"].configure(text=u'\u2713\u2713\u2713')
    selectedCgraParam.compilationDone = True

    # collect the potentially targeting kernel/function
    irFile = open('kernel.ll', 'r')
    irLines = irFile.readlines()

    # Strips the newline character
    selectedCgraParam.targetKernels = []
    for line in irLines:
        if "define " in line and "{" in line and "@" in line:
            funcName = line.split("@")[1].split("(")[0]
            if "main" not in funcName:
                selectedCgraParam.targetKernels.append(funcName)

    irFile.close()

    kernelNameMenu = widgets["kernelNameMenu"]
    kernelPannel = widgets["kernelPannel"]
    # kernelNameMenu["menu"].delete(0, "end")
    kernelNameMenu.destroy()
    kernelNameOptions = [kernelName for kernelName in selectedCgraParam.targetKernels]
    kernelNameMenu = customtkinter.CTkOptionMenu(kernelPannel, variable=kernelOptions, values=kernelNameOptions)
    kernelNameMenu.grid(row=2, column=1)
    widgets["kernelNameMenu"] = kernelNameMenu
    # for kernelName in cgraParam.targetKernels:
    #     # kernelNameMenu["menu"].add_command(label=kernelName, command=tkinter._setit(kernelOptions, kernelName))
    #     logging.info(f'kernelName: {kernelName}')
    # options.set(my_list[0])

    widgets["generateDFGShow"].configure(text="IDLE")

    os.chdir("..")


def clickKernelMenu(*args):
    global selectedCgraParam
    name = kernelOptions.get()
    if name == None or name == " " or name == "Not selected yet":
        return
    selectedCgraParam.targetKernelName = name


def dumpCgraParam2JSON(fileName, cgraParamJson):
    global selectedCgraParam
    # cgraParamJson = {}
    cgraParamJson["tiles"] = {}
    for tile in selectedCgraParam.tiles:
        curDict = {}
        if tile.disabled:
            curDict["disabled"] = True
        else:
            curDict["disabled"] = False
            if tile.isDefaultFus():
                curDict["supportAllFUs"] = True
            else:
                curDict["supportAllFUs"] = False
                curDict["supportedFUs"] = []
                for fuType in tile.fuDict:
                    if tile.fuDict[fuType] == 1:
                        curDict["supportedFUs"].append(fuType)

            if tile.hasFromMem() and (tile.fuDict["mem"] == 1 or tile.fuDict["mem_indexed"] == 1) and \
                    tile.hasToMem() and (tile.fuDict["mem"] == 1 or tile.fuDict["mem_indexed"] == 1):
                curDict["accessMem"] = True

        cgraParamJson["tiles"][str(tile.ID)] = curDict

    cgraParamJson["links"] = []
    for link in selectedCgraParam.updatedLinks:
        curDict = {}
        srcTile = link.srcTile
        dstTile = link.dstTile
        if not link.disabled and not srcTile.disabled and not dstTile.disabled and type(srcTile) != ParamSPM and type(
                dstTile) != ParamSPM:
            curDict["srcTile"] = srcTile.ID
            curDict["dstTile"] = dstTile.ID
            cgraParamJson["links"].append(curDict)

    cgraParamJsonObject = json.dumps(cgraParamJson, indent=4)

    # Writing to sample.json
    with open(fileName, "w") as outfile:
        outfile.write(cgraParamJsonObject)


def clickShowDFG():
    os.system("mkdir kernel")
    os.chdir("kernel")
    fileExist = os.path.exists("kernel.bc")
    global selectedCgraParam

    if not fileExist or not selectedCgraParam.compilationDone or selectedCgraParam.targetKernelName == None:
        os.chdir("..")
        tkinter.messagebox.showerror(title="DFG Generation",
                                     message="The compilation and kernel selection need to be done first.")
        return

    selectedCgraParam.targetKernelName = kernelOptions.get()

    genDFGJson = {
        "kernel": selectedCgraParam.targetKernelName,
        "targetFunction": False,
        "targetNested": False,
        "targetLoopsID": [0],
        "doCGRAMapping": False,
        "row": selectedCgraParam.rows,
        "column": selectedCgraParam.columns,
        "vectorizationMode": "none",
        "fusionStrategy"        : [],
        "isTrimmedDemo": True,
        "heuristicMapping": True,
        "parameterizableCGRA": True,
        "bypassConstraint"      : 4,
        "isStaticElasticCGRA": False,
        "precisionAware": False,
        "ctrlMemConstraint": selectedCgraParam.configMemSize,
        "regConstraint": 12,
        "supportDVFS"           : False,
        "DVFSIslandDim"         : 2,
        "DVFSAwareMapping"      : False,
        "enablePowerGating"     : False
    }

    dumpCgraParam2JSON("param.json", genDFGJson)

    genDFGCommand = "opt-12 -load ../../CGRA-Mapper/build/src/libmapperPass.so -mapperPass ./kernel.bc"
    logging.info("trying to run opt-12")
    genDFGProc = subprocess.Popen([genDFGCommand, "-u"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)

    with genDFGProc.stdout:
        for line in iter(genDFGProc.stdout.readline, b''):
            outputLine = line.decode("ISO-8859-1")
            logging.info(outputLine)
            if "DFG node count: " in outputLine:
                selectedCgraParam.DFGNodeCount = int(outputLine.split("DFG node count: ")[1].split(";")[0])
            if "[RecMII: " in outputLine:
                selectedCgraParam.recMII = int(outputLine.split("[RecMII: ")[1].split("]")[0])

    (out, err) = genDFGProc.communicate()
    logging.info(f"opt-12 out: {out}")
    logging.info(f"opt-12 err: {err}")

    selectedCgraParam.resMII = math.ceil(
        (selectedCgraParam.DFGNodeCount + 0.0) / len(selectedCgraParam.getValidTiles())) // 1
    widgets["resMIIEntry"].delete(0, tkinter.END)
    widgets["resMIIEntry"].insert(0, selectedCgraParam.resMII)

    widgets["recMIIEntry"].delete(0, tkinter.END)
    widgets["recMIIEntry"].insert(0, selectedCgraParam.recMII)

    convertCommand = "dot -Tpng " + selectedCgraParam.targetKernelName + ".dot -o kernel.png"
    convertProc = subprocess.Popen([convertCommand, "-u"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    (out, err) = convertProc.communicate()

    # Gets the size of the whole window
    master.update_idletasks()
    window_width = master.winfo_width()
    window_height = master.winfo_height()

    PIL_image = Image.open("kernel.png")
    ImageFile.LOAD_TRUNCATED_IMAGES = True
    PIL_image_stretched = PIL_image.resize((window_width // 6, window_height // 3), Image.Resampling.BILINEAR)
    PIL_image_stretched = PIL_image_stretched.convert("RGBA")
    datas = PIL_image_stretched.getdata()

    new_data = []
    for item in datas:
        if item[0] == 255 and item[1] == 255 and item[2] == 255:
            # Makes the white parts of the image white
            new_data.append((255, 255, 255, 255))
        else:
            new_data.append(item)
    PIL_image_stretched.putdata(new_data)

    # dfgImage = ImageTk.PhotoImage(PIL_image_stretched)
    dfgImage = customtkinter.CTkImage(PIL_image_stretched, size=(260, 380))
    images[
        "dfgImage"] = dfgImage  # This is important due to the garbage collection would remove local variable of image
    widgets["dfgLabel"].configure(image=dfgImage)

    widgets["generateDFGShow"].configure(text=u'\u2713\u2713\u2713')

    os.chdir("..")


mappingProc = None


def countMapTime():
    global mappingProc
    timeCost = 0.0
    while mappingProc == None or mappingProc.poll() is None:
        time.sleep(0.1)
        widgets["mapTimeEntry"].delete(0, tkinter.END)
        widgets["mapTimeEntry"].insert(0, round(timeCost, 1))
        timeCost += 0.1


def drawSchedule():
    global mappingProc
    mappingCommand = "opt-12 -load ../../CGRA-Mapper/build/src/libmapperPass.so -mapperPass ./kernel.bc"
    mappingProc = subprocess.Popen(["exec " + mappingCommand, '-u'], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                   shell=True, bufsize=1)
    (out, err) = mappingProc.communicate()
    success = False
    mappingII = -1
    line = out.decode("ISO-8859-1")
    if "Mapping Success" in line:
        success = True
    if "[Mapping II: " in line:
        strMapII = line.split("[Mapping II: ")[1].split("]")[0]
        mappingII = int(strMapII)

    if not success or mappingII == -1:
        tkinter.messagebox.showerror(title="DFG mapping", message="Mapping failed.")
        os.chdir("..")
        return

    widgets["mapIIEntry"].delete(0, tkinter.END)
    widgets["mapIIEntry"].insert(0, mappingII)
    widgets["mapSpeedupEntry"].delete(0, tkinter.END)
    widgets["mapSpeedupEntry"].insert(0, selectedCgraParam.DFGNodeCount / mappingII)

    # pad contains tile and links
    tileWidth = selectedCgraParam.tiles[0].width
    tileHeight = selectedCgraParam.tiles[0].height
    padWidth = tileWidth + LINK_LENGTH
    padHeight = tileHeight + LINK_LENGTH
    baseX = 0

    # load schedule.json for mapping demonstration
    f = open("schedule.json")
    schedule = json.load(f)

    # Iterating through the json
    for strTileID in schedule["tiles"]:
        tileID = int(strTileID)
        tile = selectedCgraParam.getTileOfID(tileID)
        for strCycle in schedule["tiles"][strTileID]:
            cycle = int(strCycle)
            optID = schedule["tiles"][strTileID][strCycle]
            tile.mapping[cycle] = optID[0]

    for strSrcTileID in schedule["links"]:
        for strDstTileID in schedule["links"][strSrcTileID]:
            srcTile = selectedCgraParam.getTileOfID(int(strSrcTileID))
            dstTile = selectedCgraParam.getTileOfID(int(strDstTileID))
            link = selectedCgraParam.getUpdatedLink(srcTile, dstTile)
            for cycle in schedule["links"][strSrcTileID][strDstTileID]:
                link.mapping.add(cycle)

    f.close()
    os.chdir("..")

    canvas = widgets["mappingCanvas"]
    canvas.delete("all")
    # ROWS = widgets["ROWS"]
    # COLS = widgets["COLS"]
    GRID_WIDTH = (TILE_WIDTH + LINK_LENGTH) * selectedCgraParam.columns - LINK_LENGTH
    GRID_HEIGHT = (TILE_HEIGHT + LINK_LENGTH) * selectedCgraParam.rows - LINK_LENGTH
    cgraWidth = GRID_WIDTH + MEM_WIDTH + LINK_LENGTH + 20
    canvas.configure(scrollregion=(0, 0, mappingII * cgraWidth, GRID_HEIGHT + 40 + BORDER))

    for ii in range(mappingII):
        # draw data memory
        # spmLabel = tkinter.Label(canvas, text="Data\nSPM", fg='black', bg='gray', relief='raised', bd=BORDER,
        #                          highlightbackground="black", highlightthickness=HIGHLIGHT_THICKNESS)
        spmLabel = customtkinter.CTkButton(canvas, text="Data\nSPM", state='disabled', text_color_disabled='white')
        canvas.create_window(baseX + BORDER, BORDER, window=spmLabel, height=GRID_HEIGHT, width=MEM_WIDTH, anchor="nw")

        mapped_tile_color = mapped_tile_color_list[ii % len(mapped_tile_color_list)]

        # draw tiles
        for tile in selectedCgraParam.tiles:
            if not tile.disabled:
                button = None
                if ii in tile.mapping:
                    # button = tkinter.Label(canvas, text="Opt " + str(tile.mapping[ii]), fg="black", bg="cornflowerblue",
                    #                        relief="raised", bd=BORDER, highlightbackground="black",
                    #                        highlightthickness=HIGHLIGHT_THICKNESS)
                    button = customtkinter.CTkButton(canvas, text="Opt " + str(tile.mapping[ii]), state='disabled',
                                                     border_width=2,
                                                     font=customtkinter.CTkFont(weight="bold"),
                                                     text_color_disabled='black',
                                                     fg_color=mapped_tile_color,
                                                     border_color=mapped_tile_color)
                else:
                    # button = tkinter.Label(canvas, text="Tile " + str(tile.ID), fg="black", bg="grey", relief="raised",
                    #                        bd=BORDER, highlightbackground="black",
                    #                        highlightthickness=HIGHLIGHT_THICKNESS)
                    button = customtkinter.CTkButton(canvas, text="Tile " + str(tile.ID), state='disabled',
                                                     text_color_disabled='white')
                posX, posY = tile.getPosXY(baseX + BORDER, BORDER)
                canvas.create_window(posX, posY, window=button, height=tileHeight, width=tileWidth, anchor="nw")

        # draw links
        for link in selectedCgraParam.updatedLinks:
            if not link.disabled:
                srcX, srcY = link.getSrcXY(baseX + BORDER, BORDER)
                dstX, dstY = link.getDstXY(baseX + BORDER, BORDER)
                if ii in link.mapping:
                    canvas.create_line(srcX, srcY, dstX, dstY, arrow=tkinter.LAST, width=3, fill=mapped_tile_color)
                else:
                    canvas.create_line(srcX, srcY, dstX, dstY, arrow=tkinter.LAST, fill=CANVAS_LINE_COLOR)

        # cycleLabel = tkinter.Label(canvas, text="Cycle " + str(ii))
        cycleLabel = customtkinter.CTkLabel(canvas, text="Cycle " + str(ii) + " ",
                                            font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
        canvas.create_window(baseX + (cgraWidth) / 2, GRID_HEIGHT + 30 + BORDER, window=cycleLabel, height=20, width=80)

        baseX += GRID_WIDTH + MEM_WIDTH + LINK_LENGTH + 20
        canvas.create_line(baseX - 5, INTERVAL, baseX - 5, GRID_HEIGHT, width=2, dash=(10, 2), fill="grey")


def clickTerminateMapping():
    global mappingProc
    if mappingProc == None:
        return

    if mappingProc.poll() is None:
        mappingProc.kill()

    path = os.getcwd()
    if path.split("\\")[-1] == "kernel":
        os.chdir("..")


def clickMapDFG():
    global mappingProc
    mappingProc = None
    heuristic = mappingAlgoCheckVar.get() == 0

    os.system("mkdir kernel")
    os.chdir("kernel")
    fileExist = os.path.exists("kernel.bc")
    global selectedCgraParam

    if not fileExist or not selectedCgraParam.compilationDone or selectedCgraParam.targetKernelName == None:
        os.chdir("..")
        # tkinter.messagebox.showerror(title="DFG mapping", message="The compilation and kernel selection need to be done first.")
        if not fileExist:
            tkinter.messagebox.showerror(title="DFG mapping", message="The kernel.bc doesn't exist.")
        if not selectedCgraParam.compilationDone:
            tkinter.messagebox.showerror(title="DFG mapping", message="The compilation needs to be done first.")
        if selectedCgraParam.targetKernelName == None:
            tkinter.messagebox.showerror(title="DFG mapping", message="The kernel name is not selected yet.")
        return

    if selectedCgraParam.rows == 1 and selectedCgraParam.columns == 1:
        os.chdir("..")
        tkinter.messagebox.showerror(title="DFG mapping", message="Please model the CGRA architecture with more than 1 tile.")
        return

    mappingJson = {
        "kernel": selectedCgraParam.targetKernelName,
        "targetFunction": False,
        "targetNested": False,
        "targetLoopsID": [0],
        "doCGRAMapping": True,
        "row": selectedCgraParam.rows,
        "column": selectedCgraParam.columns,
        "vectorizationMode": "none",
        "fusionStrategy"        : [],
        "isTrimmedDemo": True,
        "heuristicMapping": True,
        "parameterizableCGRA": True,
        "bypassConstraint"      : 4,
        "isStaticElasticCGRA": False,
        "precisionAware": False,
        "ctrlMemConstraint": selectedCgraParam.configMemSize,
        "regConstraint": 12,
        "supportDVFS"           : False,
        "DVFSIslandDim"         : 2,
        "DVFSAwareMapping"      : False,
        "enablePowerGating"     : False,
    }

    dumpCgraParam2JSON("param.json", mappingJson)

    mappingCommand = "opt-12 -load ../../CGRA-Mapper/build/src/libmapperPass.so -mapperPass ./kernel.bc"

    widgets["mapTimeEntry"].delete(0, tkinter.END)
    widgets["mapTimeEntry"].insert(0, 0)

    drawer = threading.Thread(target=drawSchedule)
    drawer.start()
    timer = threading.Thread(target=countMapTime)
    timer.start()


def _on_mousewheel(canvas, event):
    platformSystem = platform.system()
    logging.info(f"Current platform.system: {platformSystem}")
    if platformSystem == "Windows":
        canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
    elif platformSystem == "Linux":
        canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
    else:
        canvas.yview_scroll(int(-1 * event.delta), "units")


# Defines selected cgra frame in multi-cgra panel.
selected_cgra_frame = None


def cgra_frame_clicked(event, cgraId, frame):
    global selected_cgra_frame, selectedCgraParam
    if selected_cgra_frame and selected_cgra_frame != frame:
        selected_cgra_frame.config(bg=MULTI_CGRA_FRAME_COLOR)
        selected_cgra_frame.is_selected = False

    if getattr(frame, 'is_selected', False) == False:
        logging.info(f"cgraId: {cgraId} selected!")
        frame.is_selected = True
        frame.config(bg=MULTI_CGRA_SELECTED_COLOR)
        selected_cgra_frame = frame
        multiCgraParam.setSelectedCgra(cgraId // multiCgraParam.rows, cgraId % multiCgraParam.cols)
        selectedCgraParam = multiCgraParam.getSelectedCgra()
        selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                                   updateFunCheckoutButtons=updateFunCheckoutButtons,
                                                   updateFunCheckVars=updateFunCheckVars,
                                                   updateXbarCheckbuttons=updateXbarCheckbuttons,
                                                   updateXbarCheckVars=updateXbarCheckVars,
                                                   getFunCheckVars=getFunCheckVars,
                                                   getXbarCheckVars=getXbarCheckVars)
        # Only re-draw if this re-draw is triggered from user click
        if (event != None):
            create_cgra_pannel(master, selectedCgraParam.rows, selectedCgraParam.columns)
            create_param_pannel(master)
    else:
        logging.info(f"cgraId: {cgraId} unselected!, do nothing")


def create_multi_cgra_panel(master, cgraRows=2, cgraCols=2):
    multiCgraPanel = customtkinter.CTkFrame(master)
    # multiCgraPanel.grid(row=0, column=0, padx=(0, 5), sticky="nsew")
    multiCgraLabel = customtkinter.CTkLabel(multiCgraPanel, text='Multi-CGRA',
                                            font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    multiCgraLabel.pack(anchor="w", ipadx=5)
    multiCgraCanvas = customtkinter.CTkCanvas(multiCgraPanel, bg=CANVAS_BG_COLOR, bd=0, highlightthickness=0)

    # canvas base 0, 0
    # suppose default rowsxcols 2x2, may extra operation to connect cgra frames when one row only
    xStartPos, yStartPos = 0, 0
    distanceOfCgraAndRouter = 20
    cgraSquareLength = 80  # 100
    routerDiameter = cgraSquareLength / 4
    distanceOfCgras = 140  # 200

    # Pre-calculate positions for all CGRAs
    positions = []
    x, y = xStartPos, yStartPos
    for row in range(cgraRows):
        row_positions = []
        for col in range(cgraCols):
            row_positions.append((x, y))
            x = x + distanceOfCgras
        positions.append(row_positions)
        x = xStartPos
        y = y + distanceOfCgras

    # Draw CGRAs in the new order (bottom to top, left to right)
    cgraId = 0
    for row in range(cgraRows-1, -1, -1):  # Start from bottom row
        for col in range(cgraCols):  # Left to right
            x, y = positions[row][col]
            
            # draw
            logging.info(f"cgraFrame: {x} x {y}, cgraSquareLength: {cgraSquareLength}")
            cgraFrame = tkinter.Frame(multiCgraCanvas, bg=MULTI_CGRA_FRAME_COLOR, border=4)
            cgraFrame.is_selected = False
            # add command for frame
            cgraFrame.bind('<Button-1>', partial(cgra_frame_clicked, cgraId=cgraId, frame=cgraFrame))
            multiCgraCanvas.create_window(x, y, window=cgraFrame, height=cgraSquareLength, width=cgraSquareLength,
                                          anchor="nw")
            multiCgraCanvas.create_text(x + cgraSquareLength / 2 + 5, y + cgraSquareLength + 10,
                                        font=customtkinter.CTkFont(weight="bold"),
                                        text=f"CGRA {cgraId}", fill=MULTI_CGRA_TXT_COLOR)
            if (multiCgraParam.getCgraParam(cgraRows-1-row, col) == selectedCgraParam):
                cgra_frame_clicked(None, cgraId=cgraId, frame=cgraFrame)
                # current cgra param model is the selected one, hightlight it.
            cgraId = cgraId + 1

            # todo
            # mock the last col's tile to 3x3, need make it configurable
            # if(col != cols - 1):
            # if col == 0 and row == 0:
            create_cgra_tiles_on_multi_cgra_panel(multiCgraCanvas, x, y, 4, 4, cgraSquareLength)

            # router for each cgra frame
            multiCgraCanvas.create_oval(x + cgraSquareLength + distanceOfCgraAndRouter,
                                        y + cgraSquareLength + distanceOfCgraAndRouter,
                                        x + cgraSquareLength + distanceOfCgraAndRouter + routerDiameter,
                                        y + cgraSquareLength + distanceOfCgraAndRouter + routerDiameter,
                                        fill=MULTI_CGRA_FRAME_COLOR)
            # line between cgra and router
            multiCgraCanvas.create_line(x + cgraSquareLength, y + cgraSquareLength,
                                        x + cgraSquareLength + distanceOfCgraAndRouter + 5,
                                        y + cgraSquareLength + distanceOfCgraAndRouter + 5, fill=CANVAS_LINE_COLOR)

            routerCenterX, routerCenterY = x + cgraSquareLength + distanceOfCgraAndRouter + routerDiameter / 2, y + cgraSquareLength + distanceOfCgraAndRouter + routerDiameter / 2
            # if not last col: draws horizontal line, connects to right route
            if col != cgraCols - 1:
                rightRouterLeftEdgeX = routerCenterX + distanceOfCgras - routerDiameter / 2
                rightRouterCenterY = routerCenterY
                multiCgraCanvas.create_line(routerCenterX + routerDiameter / 2, routerCenterY, rightRouterLeftEdgeX,
                                            rightRouterCenterY, fill=CANVAS_LINE_COLOR, arrow=tkinter.BOTH, width=2)
                # multiCgraCanvas.create_line(rightRouterLeftEdgeX, rightRouterCenterY, routerCenterX + routerDiameter / 2, routerCenterY, fill=CANVAS_LINE_COLOR, arrow=tkinter.LAST, width=2)
            # if not last row: draws a vertical line, connects to down route
            # Note: since we're drawing bottom to top, we connect to the router above
            if row != 0:  # Not the top row in display (which is bottom row logically)
                upRouterCenterX = routerCenterX
                upRouterDownEdgeY = routerCenterY - distanceOfCgras + routerDiameter / 2
                multiCgraCanvas.create_line(routerCenterX, routerCenterY - routerDiameter / 2, upRouterCenterX,
                                            upRouterDownEdgeY, fill=CANVAS_LINE_COLOR, arrow=tkinter.BOTH, width=2)
                # multiCgraCanvas.create_line(upRouterCenterX, upRouterDownEdgeY, routerCenterX, routerCenterY - routerDiameter / 2, fill=CANVAS_LINE_COLOR, arrow=tkinter.LAST, width=2)

    vbar = customtkinter.CTkScrollbar(multiCgraPanel, orientation="vertical", command=multiCgraCanvas.yview)
    vbar.pack(side=tkinter.RIGHT, fill="y")
    multiCgraCanvas.config(yscrollcommand=vbar.set)

    scrollregionTuple = multiCgraCanvas.bbox("all")
    adjustTuple = (30, 30, -30, -30)
    adjustScrollregionTuple = tuple(x - y for x, y in zip(scrollregionTuple, adjustTuple))

    multiCgraCanvas.config(scrollregion=adjustScrollregionTuple)
    hbar = customtkinter.CTkScrollbar(multiCgraPanel, orientation="horizontal", command=multiCgraCanvas.xview)
    hbar.pack(side="bottom", fill="x")
    multiCgraCanvas.config(xscrollcommand=hbar.set)

    multiCgraCanvas.pack(side="top", fill="both", expand=True)

    return multiCgraPanel


def create_cgra_tiles_on_multi_cgra_panel(parentCanvas, rootX, rootY, rows, cols, cgraSquareLength):
    # mork cgra nxn
    intraCgraTileRows = rows
    intraCgraTileCols = cols
    tileXMargin, tileYMargin = 10, 10
    intraCgraTileMargin = 10

    # n*tileLen + (n-1)*tileMargin = (cgraSquareLength - intraCgraTileMargin*2)
    tileXLength = ((cgraSquareLength - intraCgraTileMargin * 2) - (
            intraCgraTileCols - 1) * tileXMargin) / intraCgraTileCols
    tileYLength = ((cgraSquareLength - intraCgraTileMargin * 2) - (
            intraCgraTileRows - 1) * tileYMargin) / intraCgraTileRows

    tileSquareLength = min(tileXLength, tileYLength)
    # need adjust tileXMargin
    if tileXLength > tileYLength:
        tileXMargin = ((cgraSquareLength - intraCgraTileMargin * 2) - (tileSquareLength * intraCgraTileCols)) / (
                intraCgraTileCols - 1)
    else:
        tileYMargin = ((cgraSquareLength - intraCgraTileMargin * 2) - (tileSquareLength * intraCgraTileRows)) / (
                intraCgraTileRows - 1)

    tileX, tileY = rootX + intraCgraTileMargin, rootY + intraCgraTileMargin
    for cgraRow in range(intraCgraTileRows):
        for cgraCol in range(intraCgraTileCols):
            cgraTileFrame = tkinter.Frame(parentCanvas, bg=MULTI_CGRA_TILE_COLOR, border=4)
            parentCanvas.create_window(tileX, tileY, window=cgraTileFrame, height=tileSquareLength,
                                       width=tileSquareLength,
                                       anchor="nw")
            tileX = tileX + tileSquareLength + tileXMargin
        tileX = rootX + intraCgraTileMargin
        tileY = tileY + tileSquareLength + tileYMargin


def create_multi_cgra_config_panel(master):
    multiCgraConfigPanel = customtkinter.CTkFrame(master, width=240)
    multiCgraConfigPanel.grid_propagate(0)
    # multiCgraConfigPanel.grid(row=0, column=1, sticky="nsew")
    for i in range(8):
        multiCgraConfigPanel.rowconfigure(i, weight=1)
    multiCgraConfigPanel.rowconfigure(8, weight=10)
    for i in range(2):
        multiCgraConfigPanel.columnconfigure(i, weight=1)

    multiCgraConfigLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Multi-CGRA Modeling',
                                                  font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    multiCgraConfigLabel.grid(row=0, column=0, columnspan=2, ipadx=5, pady=(5, 0), sticky="nw")

    totalSRAMSizeLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Per-CGRA\nSRAM (KBs):')
    totalSRAMSizeLabel.grid(row=1, column=0, padx=5, sticky="w")
    totalSRAMSizeLabelEntry = customtkinter.CTkEntry(multiCgraConfigPanel, justify=tkinter.CENTER)
    totalSRAMSizeLabelEntry.grid(row=1, column=1, padx=5)
    totalSRAMSizeLabelEntry.insert(0, str(32))

    interCgraTopologyLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Inter-CGRA\ntopology:')
    interCgraTopologyLabel.grid(row=2, column=0, padx=5, sticky="w")
    interCgraTopologyOptions = [
        "Mesh",
        "Ring"
    ]
    topologyVariable = tkinter.StringVar(multiCgraConfigPanel)
    topologyVariable.set(interCgraTopologyOptions[0])
    topologyOptionMenu = customtkinter.CTkOptionMenu(multiCgraConfigPanel, variable=topologyVariable,
                                                     values=interCgraTopologyOptions)
    topologyOptionMenu.grid(row=2, column=1, padx=5)

    multiCgraRowsLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Multi-CGRA\nRows:')
    multiCgraRowsLabel.grid(row=3, column=0, padx=5, sticky="w")
    multiCgraRowsLabelEntry = customtkinter.CTkEntry(multiCgraConfigPanel, justify=tkinter.CENTER)
    multiCgraRowsLabelEntry.grid(row=3, column=1, padx=5)
    multiCgraRowsLabelEntry.insert(0, str(CGRA_ROWS))
    widgets["multiCgraRowsLabelEntry"] = multiCgraRowsLabelEntry

    multiCgraColumnsLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Multi-CGRA\nColumns:')
    multiCgraColumnsLabel.grid(row=4, column=0, padx=5, sticky="w")
    multiCgraColumnsEntry = customtkinter.CTkEntry(multiCgraConfigPanel, justify=tkinter.CENTER)
    multiCgraColumnsEntry.grid(row=4, column=1, padx=5)
    multiCgraColumnsEntry.insert(0, str(CGRA_COLS))
    widgets["multiCgraColumnsEntry"] = multiCgraColumnsEntry

    vectorLanesLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Vector Lanes:')
    vectorLanesLabel.grid(row=5, column=0, padx=5, sticky="w")
    vectorLanesEntry = customtkinter.CTkEntry(multiCgraConfigPanel, justify=tkinter.CENTER)
    vectorLanesEntry.grid(row=5, column=1, padx=5)
    vectorLanesEntry.insert(0, str(4))

    dataBitwidthLabel = customtkinter.CTkLabel(multiCgraConfigPanel, text='Data Bitwidth:')
    dataBitwidthLabel.grid(row=6, column=0, padx=5, sticky="w")
    dataBitwidthEntry = customtkinter.CTkEntry(multiCgraConfigPanel, justify=tkinter.CENTER)
    dataBitwidthEntry.grid(row=6, column=1, padx=5)
    dataBitwidthEntry.insert(0, str(32))

    multiCgraConfigUpdateButton = customtkinter.CTkButton(multiCgraConfigPanel, text="Update",
                                                          command=partial(clickMultiCgraUpdate, master))
    multiCgraConfigUpdateButton.grid(row=7, column=0, columnspan=2, sticky="ew", padx=5, pady=5)

    # Stores varibles into the widgets.
    widgets["totalSRAMSizeLabelEntry"] = totalSRAMSizeLabelEntry
    widgets["topologyVariable"] = topologyVariable
    widgets["vectorLanesEntry"] = vectorLanesEntry
    widgets["dataBitwidthEntry"] = dataBitwidthEntry

    return multiCgraConfigPanel


def clickMultiCgraUpdate(root):
    cgraRows = int(widgets["multiCgraRowsLabelEntry"].get())
    cgraCols = int(widgets["multiCgraColumnsEntry"].get())

    # Refreshes the multi-cgra data model when row/col changes
    global multiCgraParam
    global selectedCgraParam

    multiCgraParam = MultiCGRAParam(rows=cgraRows, cols=cgraCols, globalWidgets=widgets)
    multiCgraParam.setSelectedCgra(0, 0)
    selectedCgraParam = multiCgraParam.getSelectedCgra()
    selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                               updateFunCheckoutButtons=updateFunCheckoutButtons,
                                               updateFunCheckVars=updateFunCheckVars,
                                               updateXbarCheckbuttons=updateXbarCheckbuttons,
                                               updateXbarCheckVars=updateXbarCheckVars,
                                               getFunCheckVars=getFunCheckVars,
                                               getXbarCheckVars=getXbarCheckVars)

    multiCgraPanel = create_multi_cgra_panel(root, cgraRows, cgraCols)
    multiCgraPanel.grid(row=0, column=0, padx=(0, 5), sticky="nsew")
    create_cgra_pannel(root, selectedCgraParam.rows, selectedCgraParam.columns)
    create_param_pannel(root)


def updateMultiCgraPanelOnly(root):
    """Only update Multi-CGRA panel visualization without resetting Per-CGRA entries."""
    cgraRows = int(widgets["multiCgraRowsLabelEntry"].get())
    cgraCols = int(widgets["multiCgraColumnsEntry"].get())

    global multiCgraParam
    global selectedCgraParam

    multiCgraParam = MultiCGRAParam(rows=cgraRows, cols=cgraCols, globalWidgets=widgets)
    multiCgraParam.setSelectedCgra(0, 0)
    selectedCgraParam = multiCgraParam.getSelectedCgra()
    selectedCgraParam.set_cgra_param_callbacks(switchDataSPMOutLinks=switchDataSPMOutLinks,
                                               updateFunCheckoutButtons=updateFunCheckoutButtons,
                                               updateFunCheckVars=updateFunCheckVars,
                                               updateXbarCheckbuttons=updateXbarCheckbuttons,
                                               updateXbarCheckVars=updateXbarCheckVars,
                                               getFunCheckVars=getFunCheckVars,
                                               getXbarCheckVars=getXbarCheckVars)

    # Only update Multi-CGRA panel, don't touch Per-CGRA panels
    multiCgraPanel = create_multi_cgra_panel(root, cgraRows, cgraCols)
    multiCgraPanel.grid(row=0, column=0, padx=(0, 5), sticky="nsew")


def create_cgra_pannel(master, rows, columns):
    # Clear previous CGRA panel if it exists
    if 'cgraPannel' in widgets:
        logging.info("cgra_pannel exists, destroy the original view")
        widgets["cgraPannel"].destroy()

    logging.info(f"create_cgra_pannel - ROWS: {rows}, COLS: {columns}")
    # master.grid_propagate(0)
    # Use solid black board to let the pannel look better
    cgraPannel = customtkinter.CTkFrame(master)
    widgets['cgraPannel'] = cgraPannel
    # cgraPannel = tkinter.LabelFrame(master, text='CGRA', bd=BORDER, relief='groove')
    # cgraPannel.grid(row=0, column=2, rowspan=1, columnspan=2, padx=(5, 5), sticky="nsew")
    # cgraPannel.pack()
    # cgraPannel.grid_propagate(0)
    # create label for cgraPannel
    cgraLabel = customtkinter.CTkLabel(cgraPannel, text='Per-CGRA (id: 0)',
                                       font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    widgets['cgraLabel'] = cgraLabel

    widgets["cgraLabel"].configure(text=f"Per-CGRA (id: {multiCgraParam.getSelectedCgraId()})")

    # cgraLabel.grid(row=0, column=0, sticky="nsew")
    cgraLabel.pack(anchor="w", ipadx=5)

    canvas = customtkinter.CTkCanvas(cgraPannel, bg=CANVAS_BG_COLOR, bd=0, highlightthickness=0)
    # with Windows OS
    # canvas.bind_all("<MouseWheel>", partial(_on_mousewheel, canvas))
    # with Linux OS
    # canvas.bind_all("<Button-4>", partial(_on_mousewheel, canvas))
    # canvas.bind_all("<Button-5>", partial(_on_mousewheel, canvas))

    widgets["canvas"] = canvas
    baseX = 0

    # construct data memory
    if selectedCgraParam.dataSPM == None:
        dataSPM = ParamSPM(MEM_WIDTH, rows, rows)
        selectedCgraParam.initDataSPM(dataSPM)

    # pad contains tile and links
    # padSize = TILE_SIZE + LINK_LENGTH
    padHeight = TILE_HEIGHT + LINK_LENGTH
    padWidth = TILE_WIDTH + LINK_LENGTH

    GRID_HEIGHT = (TILE_HEIGHT + LINK_LENGTH) * rows - LINK_LENGTH
    # draw data memory
    memHeight = GRID_HEIGHT
    # spmLabel = tkinter.Button(canvas, text="Data\nSPM", fg='black', bg='gray', relief='raised', bd=BORDER,
    #                           command=clickSPM, highlightbackground="black", highlightthickness=HIGHLIGHT_THICKNESS)
    spmLabel = customtkinter.CTkButton(canvas, text="Data\nSPM",
                                       # fg='black', bg='gray', relief='raised', bd=BORDER,
                                       command=clickSPM  # ,
                                       # highlightbackground="black",
                                       # highlightthickness=HIGHLIGHT_THICKNESS
                                       )
    # Data memory will be placed in the upper left corner
    canvas.create_window(baseX + BORDER, BORDER, window=spmLabel, height=GRID_HEIGHT, width=MEM_WIDTH, anchor="nw")

    # construct tiles
    if len(selectedCgraParam.tiles) == 0:
        for i in range(rows):
            for j in range(columns):
                ID = i * columns + j
                posX = padWidth * j + MEM_WIDTH + LINK_LENGTH
                posY = GRID_HEIGHT - padHeight * i - TILE_HEIGHT

                tile = ParamTile(ID, j, i, posX, posY, TILE_WIDTH, TILE_HEIGHT)
                selectedCgraParam.addTile(tile)

    # draw tiles
    logging.info(f"create_cgra_pannel - selectedCgraParam has : {selectedCgraParam.tiles} titles")

    for tile in selectedCgraParam.tiles:
        if not tile.disabled:
            # button = tkinter.Button(canvas, text="Tile " + str(tile.ID), fg='black', bg='gray', relief='raised',
            #                         bd=BORDER, command=partial(clickTile, tile.ID), highlightbackground="black",
            #                         highlightthickness=HIGHLIGHT_THICKNESS)
            button = customtkinter.CTkButton(canvas, text="Tile " + str(tile.ID),
                                             # fg='black', bg='gray', relief='raised', bd=BORDER,
                                             command=partial(clickTile, tile.ID)  # ,
                                             # highlightbackground="black",
                                             # highlightthickness=HIGHLIGHT_THICKNESS
                                             )
            posX, posY = tile.getPosXY()
            # Tiles will be placed near the Data memory
            canvas.create_window(posX, posY, window=button, height=TILE_HEIGHT, width=TILE_WIDTH, anchor="nw")

            # construct links
    if len(selectedCgraParam.templateLinks) == 0:
        for i in range(rows):
            for j in range(columns):
                if j < columns - 1:
                    # horizontal
                    tile0 = selectedCgraParam.getTileOfDim(j, i)
                    tile1 = selectedCgraParam.getTileOfDim(j + 1, i)
                    link0 = ParamLink(tile0, tile1, PORT_EAST, PORT_WEST)
                    link1 = ParamLink(tile1, tile0, PORT_WEST, PORT_EAST)
                    selectedCgraParam.addTemplateLink(link0)
                    selectedCgraParam.addTemplateLink(link1)

                if i < rows - 1 and j < columns - 1:
                    # diagonal left bottom to right top
                    tile0 = selectedCgraParam.getTileOfDim(j, i)
                    tile1 = selectedCgraParam.getTileOfDim(j + 1, i + 1)
                    link0 = ParamLink(tile0, tile1, PORT_NORTHEAST, PORT_SOUTHWEST)
                    link1 = ParamLink(tile1, tile0, PORT_SOUTHWEST, PORT_NORTHEAST)
                    selectedCgraParam.addTemplateLink(link0)
                    selectedCgraParam.addTemplateLink(link1)

                if i < rows - 1 and j > 0:
                    # diagonal left top to right bottom
                    tile0 = selectedCgraParam.getTileOfDim(j, i)
                    tile1 = selectedCgraParam.getTileOfDim(j - 1, i + 1)
                    link0 = ParamLink(tile0, tile1, PORT_NORTHWEST, PORT_SOUTHEAST)
                    link1 = ParamLink(tile1, tile0, PORT_SOUTHEAST, PORT_NORTHWEST)
                    selectedCgraParam.addTemplateLink(link0)
                    selectedCgraParam.addTemplateLink(link1)

                if i < columns - 1:
                    # vertical
                    tile0 = selectedCgraParam.getTileOfDim(j, i)
                    tile1 = selectedCgraParam.getTileOfDim(j, i + 1)
                    link0 = ParamLink(tile0, tile1, PORT_NORTH, PORT_SOUTH)
                    link1 = ParamLink(tile1, tile0, PORT_SOUTH, PORT_NORTH)
                    selectedCgraParam.addTemplateLink(link0)
                    selectedCgraParam.addTemplateLink(link1)

                if j == 0:
                    # connect to memory
                    tile0 = selectedCgraParam.getTileOfDim(j, i)
                    link0 = ParamLink(tile0, selectedCgraParam.dataSPM, PORT_WEST, i)
                    link1 = ParamLink(selectedCgraParam.dataSPM, tile0, i, PORT_WEST)
                    selectedCgraParam.addTemplateLink(link0)
                    selectedCgraParam.addTemplateLink(link1)

    selectedCgraParam.updateLinks()
    selectedCgraParam.updateFuXbarPannel()

    # draw links
    for link in selectedCgraParam.updatedLinks:
        if link.disabled:
            pass
        else:
            srcX, srcY = link.getSrcXY()
            dstX, dstY = link.getDstXY()
            canvas.create_line(srcX, srcY, dstX, dstY, arrow=tkinter.LAST, fill=CANVAS_LINE_COLOR)

    vbar = customtkinter.CTkScrollbar(cgraPannel, orientation="vertical", command=canvas.yview)
    vbar.pack(side=tkinter.RIGHT, fill="y")
    canvas.config(yscrollcommand=vbar.set)
    canvas.config(scrollregion=canvas.bbox("all"))
    canvas.pack(side="top", fill="both", expand=True)
    hbar = customtkinter.CTkScrollbar(cgraPannel, orientation="horizontal", command=canvas.xview)
    hbar.pack(side="bottom", fill="x")
    canvas.config(xscrollcommand=hbar.set)

    cgraPannel.grid(row=0, column=2, rowspan=1, columnspan=2, padx=(5, 5), sticky="nsew")

    return cgraPannel


def place_fu_options(master):
    fuCount = len(fuTypeList)
    for i in range(len(fuTypeList)):
        fuVar = tkinter.IntVar()
        fuCheckVars[fuTypeList[i]] = fuVar
        fuCheckbutton = customtkinter.CTkCheckBox(master, variable=fuVar, text=fuTypeList[i],
                                                  command=partial(clickFuCheckbutton, fuTypeList[i]))
        fuCheckbuttons[fuTypeList[i]] = fuCheckbutton
        fuCheckbutton.select()
        selectedCgraParam.updateFuCheckbutton(fuTypeList[i], fuVar.get())
        fuCheckbutton.grid(row=(i // 2), column=i % 2, pady=6)


def place_xbar_options(master):
    for i in range(PORT_DIRECTION_COUNTS):
        portType = i
        xbarType = xbarPort2Type[i]
        xbarVar = tkinter.IntVar()
        xbarCheckVars[xbarType] = xbarVar
        xbarCheckbutton = customtkinter.CTkCheckBox(master, variable=xbarVar, text=xbarType,
                                                    command=partial(clickXbarCheckbutton, xbarType))
        xbarCheckbuttons[xbarType] = xbarCheckbutton

        if selectedCgraParam.getTileOfID(0).xbarDict[xbarType] == 1:
            xbarCheckbutton.select()

        selectedCgraParam.updateXbarCheckbutton(xbarType, xbarVar.get())

        if portType in selectedCgraParam.getTileOfID(0).neverUsedOutPorts:
            xbarCheckbutton.configure(state="disabled")

        # xbarCheckbutton.grid(row=(i // 3)+1, column=i % 3, padx=15, pady=15, sticky="nsew")
        if i == PORT_NORTH:
            xbarCheckbutton.grid(row=0, column=1, padx=5, pady=(6, 25))
        elif i == PORT_SOUTH:
            xbarCheckbutton.grid(row=2, column=1, padx=5, pady=25)
        elif i == PORT_WEST:
            xbarCheckbutton.grid(row=1, column=0, padx=5, pady=25)
        elif i == PORT_EAST:
            xbarCheckbutton.grid(row=1, column=2, padx=5, pady=25)
        elif i == PORT_NORTHWEST:
            xbarCheckbutton.grid(row=0, column=0, padx=5, pady=(6, 25))
        elif i == PORT_NORTHEAST:
            xbarCheckbutton.grid(row=0, column=2, padx=5, pady=(6, 25))
        elif i == PORT_SOUTHEAST:
            xbarCheckbutton.grid(row=2, column=2, padx=5, pady=25)
        elif i == PORT_SOUTHWEST:
            xbarCheckbutton.grid(row=2, column=0, padx=5, pady=25)

        # centralRadioButton = customtkinter.CTkRadioButton(master, text='Tile 0', variable=tkinter.IntVar(value=0))
        # centralRadioButton.configure(state="disabled")
        # centralRadioButton.grid(row=1, column=1, padx=5, pady=25)
        # widgets["centralRadioButton"] = centralRadioButton
        xbarCentralTilelabel = customtkinter.CTkLabel(master, text='Tile 0',
                                                      font=customtkinter.CTkFont(weight="bold", underline=True))
        xbarCentralTilelabel.grid(row=1, column=1, padx=(0, 5), pady=25)
        widgets["xbarCentralTilelabel"] = xbarCentralTilelabel


def create_param_pannel(master):
    # paramPannel = tkinter.LabelFrame(master, text='Configuration', bd=BORDER, relief='groove')
    paramPannel = customtkinter.CTkFrame(master, width=550, height=480)
    # paramPannel.grid(row=0, column=4, columnspan=2, sticky="nsew")

    # Use columnconfigure and rowconfigure to partition the columns, so that each column and row will fill the corresponding space
    # The 'weight' represents the weight of the corresponding row/column length
    for i in range(9):
        paramPannel.rowconfigure(i, weight=1)
    for i in range(3):
        paramPannel.columnconfigure(i, weight=1)
    paramPannel.grid_propagate(0)
    configurationLabel = customtkinter.CTkLabel(paramPannel, text='Per-CGRA Modeling',
                                                font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    configurationLabel.grid(row=0, column=0, columnspan=2, padx=(5, 0), pady=(5, 0), sticky="nw")

    rowsLabel = customtkinter.CTkLabel(paramPannel, text='Rows  Columns:')
    rowsLabel.grid(row=1, column=0)
    rowsEntry = customtkinter.CTkEntry(paramPannel, justify=tkinter.CENTER  # ,
                                       # highlightbackground="black",
                                       # highlightthickness=HIGHLIGHT_THICKNESS
                                       )
    rowsEntry.grid(row=1, column=1, padx=5, pady=5)
    rowsEntry.insert(0, str(selectedCgraParam.rows))
    widgets["rowsEntry"] = rowsEntry
    columnsEntry = customtkinter.CTkEntry(paramPannel, justify=tkinter.CENTER  # ,
                                          # highlightbackground="black",
                                          # highlightthickness=HIGHLIGHT_THICKNESS
                                          )
    columnsEntry.grid(row=1, column=2, padx=2, pady=5)
    columnsEntry.insert(0, str(selectedCgraParam.columns))
    widgets["columnsEntry"] = columnsEntry

    dataMemLabel = customtkinter.CTkLabel(paramPannel, text='Per-Bank SRAM (KBs):')
    dataMemLabel.grid(row=2, column=0)
    dataMemEntry = customtkinter.CTkEntry(paramPannel, justify=tkinter.CENTER  # ,
                                          # highlightbackground="black",
                                          # highlightthickness=HIGHLIGHT_THICKNESS
                                          )
    dataMemEntry.grid(row=2, column=1, padx=5, pady=5)
    dataMemEntry.insert(0, str(selectedCgraParam.dataMemSize))
    widgets["dataMemEntry"] = dataMemEntry
    resetButton = customtkinter.CTkButton(paramPannel, text="Reset",
                                          # relief='raised',
                                          command=partial(clickReset, master)  # ,
                                          # highlightbackground="black", highlightthickness=HIGHLIGHT_THICKNESS
                                          )
    resetButton.grid(row=2, column=2, columnspan=2)

    configMemLabel = customtkinter.CTkLabel(paramPannel, text='Config Memory \n (entries/tile):')
    configMemLabel.grid(row=3, column=0)
    configMemEntry = customtkinter.CTkEntry(paramPannel, justify=tkinter.CENTER  # ,
                                            # highlightbackground="black",
                                            # highlightthickness=HIGHLIGHT_THICKNESS
                                            )
    configMemEntry.grid(row=3, column=1, pady=5)
    configMemEntry.insert(0, selectedCgraParam.configMemSize)
    widgets["configMemEntry"] = configMemEntry
    updateButton = customtkinter.CTkButton(paramPannel, text="Update",
                                           # relief='raised',
                                           command=partial(clickUpdate, master)  # ,
                                           # highlightbackground="black", highlightthickness=HIGHLIGHT_THICKNESS
                                           )
    updateButton.grid(row=3, column=2, columnspan=2)

    entireTileCheckVar.set(0)
    entireTileCheckbutton = customtkinter.CTkCheckBox(paramPannel, variable=entireTileCheckVar,
                                                      text="Disable entire Tile 0", command=clickEntireTileCheckbutton)
    entireTileCheckbutton.grid(row=4, column=0, columnspan=2, padx=(5, 0), sticky="w")
    widgets["entireTileCheckbutton"] = entireTileCheckbutton

    # Data SPM outgoing links
    spmConfigPannel = customtkinter.CTkScrollableFrame(paramPannel, label_text="Data SPM\noutgoing links", width=80)
    spmConfigPannel.grid(row=5, column=0, rowspan=3, pady=(5, 0), sticky="nsew")
    widgets["spmConfigPannel"] = spmConfigPannel
    # spmConfigPannel.rowconfigure(0, weight=1)
    # spmConfigPannel.rowconfigure(1, weight=3)
    # for i in range(4):
    #     spmConfigPannel.columnconfigure(i, weight=1)
    # spmConfigPannel.grid_propagate(0)
    # spmConfigPannelLabel = customtkinter.CTkLabel(spmConfigPannel, text='Data SPM\noutgoing links',
    #                                               font=customtkinter.CTkFont(size=FRAME_LABEL_LEVEL_1_FONT_SIZE,
    #                                                                          weight="bold", slant='italic'))
    # spmConfigPannelLabel.grid(row=0, column=0, sticky="nsew")
    # spmConfigPannelLabel.pack()
    # spmConfigPannelLabel.grid_propagate(0)
    # spmConfigScrollablePannel = customtkinter.CTkScrollableFrame(spmConfigPannel, height=240)
    # spmConfigScrollablePannel.grid(row=1, column=0, sticky="nsew")
    # spmConfigScrollablePannel.pack()

    spmOutlinksSwitches = []
    # for i in range(10):
    #     switch = customtkinter.CTkSwitch(spmConfigScrollablePannel, text=f"link {i}")
    #     switch.select()
    #     # switch.grid(row=i + 1, column=0, padx=5, pady=(0, 10))
    #     switch.pack(pady=(5, 10))
    #     scrollable_frame_switches.append(switch)
    for port in selectedCgraParam.dataSPM.outLinks:
        switch = customtkinter.CTkSwitch(spmConfigPannel, text=f"link {port}", command=switchDataSPMOutLinks)
        if not selectedCgraParam.dataSPM.outLinks[port].disabled:
            switch.select()
        switch.pack(pady=(5, 10))
        spmOutlinksSwitches.insert(0, switch)
    widgets['spmOutlinksSwitches'] = spmOutlinksSwitches

    # Tile x functional units
    fuConfigPannel = customtkinter.CTkScrollableFrame(paramPannel, label_text="Tile 0\nfunctional units")
    fuConfigPannel.grid(row=5, column=1, rowspan=3, padx=(5, 5), pady=(5, 0), sticky="nsew")
    widgets["fuConfigPannel"] = fuConfigPannel

    # Use columnconfigure to partition the columns, so that each column fills the corresponding space
    # for i in range(2):
    #     fuConfigPannel.columnconfigure(i, weight=1)
    # fuConfigPannel.grid_propagate(0)
    # fuConfigPannelLabel = customtkinter.CTkLabel(fuConfigPannel, text='Tile 0\nfunctional units',
    #                                              font=customtkinter.CTkFont(size=FRAME_LABEL_LEVEL_1_FONT_SIZE,
    #                                                                         weight="bold", slant='italic'))
    # fuConfigPannelLabel.grid(row=0, column=0, sticky="nsew")
    # fuConfigPannelLabel.pack()
    # widgets["fuConfigPannelLabel"] = fuConfigPannelLabel
    # fuConfigSubPannel = customtkinter.CTkFrame(fuConfigPannel)
    for i in range(2):
        fuConfigPannel.columnconfigure(i, weight=1)
    place_fu_options(fuConfigPannel)
    # fuConfigSubPannel.pack()

    # Tile x crossbar outgoing links
    xbarConfigPannel = customtkinter.CTkScrollableFrame(paramPannel, label_text="Tile 0\ncrossbar outgoing links")
    xbarConfigPannel.grid(row=5, column=2, rowspan=3, pady=(5, 0), sticky="nsew")
    widgets["xbarConfigPannel"] = xbarConfigPannel

    # Use columnconfigure to partition the columns, so that each column fills the corresponding space
    # for i in range(3):
    #     xbarConfigPannel.columnconfigure(i, weight=1)
    # for i in range(4):
    #     xbarConfigPannel.rowconfigure(i, weight=1)
    # xbarConfigPannel.grid_propagate(0)
    # xbarConfigPannelLabel = customtkinter.CTkLabel(xbarConfigPannel, text='Tile 0\ncrossbar outgoing links',
    #                                                font=customtkinter.CTkFont(size=FRAME_LABEL_LEVEL_1_FONT_SIZE,
    #                                                                           weight="bold", slant='italic'))
    # # xbarConfigPannelLabel.grid(row=0, column=0, sticky="nsew")
    # xbarConfigPannelLabel.pack()
    # widgets["xbarConfigPannelLabel"] = xbarConfigPannelLabel
    # xbarConfigSubPannel = customtkinter.CTkFrame(xbarConfigPannel)
    for i in range(3):
        xbarConfigPannel.columnconfigure(i, weight=1)
    for i in range(3):
        xbarConfigPannel.rowconfigure(i, weight=1)
    place_xbar_options(xbarConfigPannel)
    # xbarConfigSubPannel.pack()
    paramPannel.grid(row=0, column=4, columnspan=2, sticky="nsew")

    return paramPannel


def create_test_pannel(master):
    dataPannel = customtkinter.CTkFrame(master, width=80, height=480)
    # dataPannel.grid(row=1, column=4, pady=(5,0), sticky="nsew")
    # Increase the size of the 'SVerilog' panel
    dataPannel.grid_rowconfigure(1, weight=2)

    dataPannel.grid_columnconfigure(0, weight=1)
    dataPannel.grid_columnconfigure(1, weight=1)
    dataPannel.grid_columnconfigure(2, weight=1)
    dataPannel.grid_propagate(0)
    # testPannel = tkinter.LabelFrame(dataPannel, text='Verification', bd=BORDER, relief='groove')
    testPannel = customtkinter.CTkFrame(dataPannel)
    testPannel.grid(row=0, column=0, rowspan=1, columnspan=3, sticky="nsew")
    testPannel.columnconfigure(0, weight=1)
    testPannel.columnconfigure(1, weight=1)
    testPannel.columnconfigure(2, weight=1)
    testPannelLabel = customtkinter.CTkLabel(testPannel, text='Verification ',
                                             # width=100,
                                             font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    testPannelLabel.grid(row=0, column=0, columnspan=3, ipadx=5, sticky="w")
    testButton = customtkinter.CTkButton(testPannel, text="Run tests",  # relief='raised',
                                         command=clickTest,
                                         width=50
                                         # highlightbackground="black", highlightthickness=HIGHLIGHT_THICKNESS
                                         )
    testButton.grid(row=1, column=0, ipadx=5)
    # testProgress = ttk.Progressbar(testPannel, orient='horizontal', mode='determinate')
    testProgress = customtkinter.CTkProgressBar(testPannel, orientation='horizontal', mode='determinate', width=160)
    testProgress.set(0)
    widgets["testProgress"] = testProgress
    testProgress.grid(row=1, column=1, rowspan=1, columnspan=1, padx=5, sticky="w")
    testShow = customtkinter.CTkLabel(testPannel, text="IDLE ")
    widgets["testShow"] = testShow
    testShow.grid(row=1, column=2, sticky=tkinter.E, padx=(5, 5))

    # verilogPannel = tkinter.LabelFrame(dataPannel, text="SVerilog", bd=BORDER, relief="groove")
    verilogPannel = customtkinter.CTkFrame(dataPannel)
    verilogPannel.grid(row=1, column=0, rowspan=1, columnspan=3, pady=(5, 5), sticky="nsew")
    verilogPannelLabel = customtkinter.CTkLabel(verilogPannel, text='SVerilog ',
                                                # width=100,
                                                font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                           weight="bold"))
    verilogPannelLabel.pack(anchor="w", padx=(5, 0))
    CreateToolTip(verilogPannel,
                  text="The code might be too big to be copied,\nthe generated verilog can be found in\nthe 'verilog' folder.")
    generateVerilogButton = customtkinter.CTkButton(verilogPannel, text="Generate", width=50,
                                                    command=clickGenerateVerilog)
    generateVerilogButton.pack(side=tkinter.BOTTOM, anchor="sw", padx=BORDER, pady=BORDER)
    # verilogScroll = tkinter.Scrollbar(verilogPannel, orient="vertical")
    # verilogScroll.pack(side=tkinter.RIGHT, fill="y")
    # verilogText = tkinter.Text(verilogPannel, yscrollcommand=verilogScroll.set, width=10, height=5)
    # verilogText.pack(side=tkinter.LEFT, fill="both", expand=True)
    # verilogScroll.config(command=verilogText.yview)
    verilogText = customtkinter.CTkTextbox(verilogPannel, width=10, height=5)
    verilogText.pack(side=tkinter.LEFT, fill="both", expand=True)
    widgets["verilogText"] = verilogText

    # reportPannel = tkinter.LabelFrame(dataPannel, text='Report area/power', bd=BORDER, relief='groove')
    reportPannel = customtkinter.CTkFrame(dataPannel)
    reportPannel.grid(row=2, column=0, rowspan=1, columnspan=3, sticky='nesw')
    reportPannel.columnconfigure(0, weight=1)
    reportPannel.columnconfigure(1, weight=1)
    reportPannelLabel = customtkinter.CTkLabel(reportPannel, text='Report Area/Power ',
                                               # width=100,
                                               font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                          weight="bold"))

    reportButton = customtkinter.CTkButton(reportPannel, text="Synthesize", command=clickSynthesize, width=60)

    reportProgress = customtkinter.CTkProgressBar(reportPannel, orientation="horizontal", mode="determinate", width=140)
    reportProgress.set(0)
    widgets["reportProgress"] = reportProgress

    synthesisTimeEntry = customtkinter.CTkEntry(reportPannel, justify=tkinter.CENTER)
    widgets["synthesisTimeEntry"] = synthesisTimeEntry

    reportTimecostLabel = customtkinter.CTkLabel(reportPannel, text=" Time cost:")
    CreateToolTip(reportTimecostLabel, text="Time is in s.")

    reportTileAreaLabel = customtkinter.CTkLabel(reportPannel, text=" Tiles area:")
    CreateToolTip(reportTileAreaLabel, text="Area is in mm^2.")

    reportTileAreaData = customtkinter.CTkEntry(reportPannel, justify=tkinter.CENTER)
    widgets["reportTileAreaData"] = reportTileAreaData

    reportTilePowerLabel = customtkinter.CTkLabel(reportPannel, text="Tiles power:")
    CreateToolTip(reportTilePowerLabel, text="Yosys is not able to provide\npower estimation.")

    reportTilePowerData = customtkinter.CTkEntry(reportPannel, justify=tkinter.CENTER)
    widgets["reportTilePowerData"] = reportTilePowerData

    reportSPMAreaLabel = customtkinter.CTkLabel(reportPannel, text=" SPM area:")
    CreateToolTip(reportSPMAreaLabel, text="Area is in mm^2.")

    reportSPMAreaData = customtkinter.CTkEntry(reportPannel, justify=tkinter.CENTER)
    widgets["reportSPMAreaData"] = reportSPMAreaData

    reportSPMPowerLabel = customtkinter.CTkLabel(reportPannel, text="SPM power:")
    CreateToolTip(reportSPMPowerLabel, text="Power is in mW.")

    reportSPMPowerData = customtkinter.CTkEntry(reportPannel, justify=tkinter.CENTER)
    widgets["reportSPMPowerData"] = reportSPMPowerData

    reportPannelLabel.grid(row=0, column=0, columnspan=2, padx=(5, 0), sticky="w")
    reportButton.grid(row=1, column=0)
    reportProgress.grid(row=1, column=1)

    synthesisTimeEntry.grid(row=2, column=1, pady=5)
    reportTimecostLabel.grid(row=2, column=0, pady=5)

    reportTileAreaLabel.grid(row=3, column=0, pady=5)
    reportTileAreaData.grid(row=3, column=1, pady=5)
    reportTilePowerLabel.grid(row=4, column=0, pady=5)
    reportTilePowerData.grid(row=4, column=1, pady=5)

    reportSPMAreaLabel.grid(row=5, column=0, pady=5)
    reportSPMAreaData.grid(row=5, column=1, pady=5)
    reportSPMPowerLabel.grid(row=6, column=0, pady=5)
    reportSPMPowerData.grid(row=6, column=1, pady=5)

    return dataPannel


def create_layout_pannel(master):
    layoutPannel = customtkinter.CTkFrame(master, width=80)
    # layoutPannel.grid(row=1, column=5, padx=(5,0), pady=(5,0), sticky="nsew")
    layoutPannel.grid_propagate(0)
    for row in range(5):
        layoutPannel.grid_rowconfigure(row, weight=1)
    layoutPannel.grid_rowconfigure(5, weight=40)
    layoutPannel.grid_columnconfigure(0, weight=1)
    layoutPannel.grid_columnconfigure(1, weight=1)
    layoutPannelLabel = customtkinter.CTkLabel(layoutPannel, text='Layout ',
                                               # width=100,
                                               font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold"))
    layoutPannelLabel.grid(row=0, column=0, padx=(5, 0), sticky="nw")

    # Adds the entry for user to select constraint.sdc
    constraintLabel = customtkinter.CTkLabel(layoutPannel, text="Constraint.sdc")
    constraintLabel.grid(row=1, column=0)
    constraintPathEntry = customtkinter.CTkEntry(layoutPannel)
    constraintPathEntry.grid(row=1, column=1)
    constraintPathEntry.bind("<Button-1>", clickSelectConstraintFile)
    widgets["constraintPathEntry"] = constraintPathEntry

    # Adds the entry for user to select config.mk
    configLabel = customtkinter.CTkLabel(layoutPannel, text="Config.mk")
    configLabel.grid(row=2, column=0, padx=(0, 5))
    configPathEntry = customtkinter.CTkEntry(layoutPannel)
    configPathEntry.grid(row=2, column=1)
    configPathEntry.bind("<Button-1>", clickSelectConfigFile)
    widgets["configPathEntry"] = configPathEntry

    # Adds the option menu to select process technology.
    processNameLabel = customtkinter.CTkLabel(layoutPannel, text="Process:")
    processNameLabel.grid(row=3, column=0)
    tempOptions = ["asap7", "nangate45", "sky130hd"]
    processNameMenu = customtkinter.CTkOptionMenu(layoutPannel, variable=processOptions, values=tempOptions)
    processNameMenu.grid(row=3, column=1, padx=(5, 5))

    # Adds the button to trigger RTL->Layout flow.
    openRoadButton = customtkinter.CTkButton(layoutPannel, text="RTL -> Layout", command=clickRTL2Layout)
    openRoadButton.grid(row=4, column=0, columnspan=2, sticky='we', padx=(10, 10))

    # Adds a placeholder to show the layout image saved from OpenRoad.
    global layoutLabel
    layoutLabel = customtkinter.CTkLabel(layoutPannel, text='')
    layoutLabel.grid(row=5, column=0, padx=(0, 5), pady=(5, 5), columnspan=2)

    return layoutPannel


def create_chat_panel(master):
    """Create the AI Assistant chat panel."""
    chatPanel = customtkinter.CTkFrame(master, width=300)
    chatPanel.grid_propagate(0)

    # Configure grid weights
    chatPanel.grid_rowconfigure(0, weight=0)  # Title row
    chatPanel.grid_rowconfigure(1, weight=0)  # Provider row
    chatPanel.grid_rowconfigure(2, weight=0)  # API Key row
    chatPanel.grid_rowconfigure(3, weight=0)  # Model config row
    chatPanel.grid_rowconfigure(4, weight=1)  # Chat display (expandable)
    chatPanel.grid_rowconfigure(5, weight=0)  # Auto-config buttons row
    chatPanel.grid_rowconfigure(6, weight=0)  # Input area
    chatPanel.grid_columnconfigure(0, weight=1)

    # Title label
    chatLabel = customtkinter.CTkLabel(
        chatPanel,
        text='AI Assistant',
        font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE, weight="bold")
    )
    chatLabel.grid(row=0, column=0, padx=(5, 0), pady=(5, 0), sticky="nw")

    # Provider selection frame
    providerFrame = customtkinter.CTkFrame(chatPanel)
    providerFrame.grid(row=1, column=0, padx=5, pady=(5, 0), sticky="ew")
    providerFrame.grid_columnconfigure(1, weight=1)

    providerLabel = customtkinter.CTkLabel(providerFrame, text="Provider:")
    providerLabel.grid(row=0, column=0, padx=(5, 5), pady=3)

    providerVar = tkinter.StringVar(value=ai_assistant.aiChatConfig["provider"])
    providerMenu = customtkinter.CTkOptionMenu(
        providerFrame,
        variable=providerVar,
        values=list(ai_assistant.AI_PROVIDERS.keys()),
        command=on_provider_change,
        width=180
    )
    providerMenu.grid(row=0, column=1, padx=(0, 5), pady=3, sticky="ew")
    widgets["providerMenu"] = providerMenu

    # API Key configuration frame
    apiFrame = customtkinter.CTkFrame(chatPanel)
    apiFrame.grid(row=2, column=0, padx=5, pady=(5, 0), sticky="ew")
    apiFrame.grid_columnconfigure(1, weight=1)

    apiKeyLabel = customtkinter.CTkLabel(apiFrame, text="API Key:")
    apiKeyLabel.grid(row=0, column=0, padx=(5, 5), pady=3)

    apiKeyEntry = customtkinter.CTkEntry(apiFrame, placeholder_text="Enter API Key...", show="*")
    apiKeyEntry.grid(row=0, column=1, padx=(0, 5), pady=3, sticky="ew")
    # Pre-fill with environment variable if available
    if ai_assistant.aiChatConfig["api_key"]:
        apiKeyEntry.insert(0, ai_assistant.aiChatConfig["api_key"])
    apiKeyEntry.bind("<FocusOut>", on_api_key_change)
    apiKeyEntry.bind("<Return>", on_api_key_change)
    widgets["apiKeyEntry"] = apiKeyEntry

    # Model configuration frame
    configFrame = customtkinter.CTkFrame(chatPanel)
    configFrame.grid(row=3, column=0, padx=5, pady=(5, 5), sticky="ew")
    configFrame.grid_columnconfigure(1, weight=1)

    # Model selection
    modelLabel = customtkinter.CTkLabel(configFrame, text="Model:")
    modelLabel.grid(row=0, column=0, padx=(5, 5), pady=3)

    current_provider = ai_assistant.aiChatConfig["provider"]
    current_models = ai_assistant.AI_PROVIDERS[current_provider]["models"]
    modelVar = tkinter.StringVar(value=ai_assistant.aiChatConfig["model"])
    modelMenu = customtkinter.CTkOptionMenu(
        configFrame,
        variable=modelVar,
        values=current_models,
        command=on_model_change,
        width=180
    )
    modelMenu.grid(row=0, column=1, padx=(0, 5), pady=3, sticky="ew")
    widgets["modelMenu"] = modelMenu

    # Chat display area (scrollable textbox)
    chatDisplay = customtkinter.CTkTextbox(
        chatPanel,
        wrap="word",
        state="disabled",
        font=customtkinter.CTkFont(size=12)
    )
    chatDisplay.grid(row=4, column=0, padx=5, pady=(0, 5), sticky="nsew")
    widgets["chatDisplay"] = chatDisplay

    # Show welcome message
    chatDisplay.configure(state="normal")
    chatDisplay.insert(tkinter.END, "CGRA-Flow AI Assistant\n")
    chatDisplay.insert(tkinter.END, "─" * 30 + "\n")
    chatDisplay.insert(tkinter.END, "• Auto Config: Describe your\n")
    chatDisplay.insert(tkinter.END, "  application for recommendations\n")
    chatDisplay.insert(tkinter.END, "• Analyze Mapping: Run mapping\n")
    chatDisplay.insert(tkinter.END, "  in Kernel panel first, then\n")
    chatDisplay.insert(tkinter.END, "  get AI optimization advice\n")
    chatDisplay.insert(tkinter.END, "─" * 30 + "\n\n")
    chatDisplay.configure(state="disabled")

    # Action buttons frame (3 rows, 1 column)
    autoConfigFrame = customtkinter.CTkFrame(chatPanel)
    autoConfigFrame.grid(row=5, column=0, padx=5, pady=(0, 5), sticky="ew")
    autoConfigFrame.grid_columnconfigure(0, weight=1)

    # Model CGRA given kernel
    autoConfigButton = customtkinter.CTkButton(
        autoConfigFrame,
        text="Generate CGRA from Given Kernel",
        command=clickAutoConfig,
        fg_color="#2E7D32",
        hover_color="#1B5E20"
    )
    autoConfigButton.grid(row=0, column=0, padx=5, pady=(5, 2), sticky="ew")
    widgets["autoConfigButton"] = autoConfigButton

    # Apply AI Generated CGRA Design
    applyConfigButton = customtkinter.CTkButton(
        autoConfigFrame,
        text="Apply AI-Generated CGRA Design",
        command=apply_recommended_config,
        state="disabled",
        fg_color="#1565C0",
        hover_color="#0D47A1"
    )
    applyConfigButton.grid(row=1, column=0, padx=5, pady=2, sticky="ew")
    widgets["applyConfigButton"] = applyConfigButton

    # Analyze Mapping
    analyzeMappingButton = customtkinter.CTkButton(
        autoConfigFrame,
        text="Analyze CGRA Mapping Report",
        command=clickAIAnalyzeCurrentState,
        fg_color="#F57C00",
        hover_color="#E65100"
    )
    analyzeMappingButton.grid(row=2, column=0, padx=5, pady=(2, 5), sticky="ew")
    widgets["analyzeMappingButton"] = analyzeMappingButton

    # Input frame
    inputFrame = customtkinter.CTkFrame(chatPanel)
    inputFrame.grid(row=6, column=0, padx=5, pady=(0, 5), sticky="ew")
    inputFrame.grid_columnconfigure(0, weight=1)
    inputFrame.grid_columnconfigure(1, weight=0)
    inputFrame.grid_columnconfigure(2, weight=0)

    # Input entry
    chatInput = customtkinter.CTkEntry(inputFrame, placeholder_text="Ask a question...")
    chatInput.grid(row=0, column=0, padx=(5, 5), pady=5, sticky="ew")
    chatInput.bind("<Return>", handle_chat_enter)
    widgets["chatInput"] = chatInput

    # Send button
    sendButton = customtkinter.CTkButton(
        inputFrame,
        text="Send",
        width=60,
        command=clickSendChat
    )
    sendButton.grid(row=0, column=1, padx=(0, 5), pady=5)
    widgets["sendButton"] = sendButton

    # Clear button
    clearButton = customtkinter.CTkButton(
        inputFrame,
        text="Clear",
        width=60,
        command=clickClearChat
    )
    clearButton.grid(row=0, column=2, padx=(0, 5), pady=5)

    return chatPanel


"""
    canvas = customtkinter.CTkCanvas(layoutPannel, bg=CANVAS_BG_COLOR, bd=0, highlightthickness=0)
    scrollbar = customtkinter.CTkScrollbar(layoutPannel, orientation="horizontal", command=canvas.xview)
    scrollbar.pack(side="bottom", fill="x")
    canvas.config(xscrollcommand=scrollbar.set)
    canvas.pack(side="top", fill="both", expand=True)
    layout_frame = customtkinter.CTkFrame(canvas)
    canvas.create_window((0, 0), window=layout_frame, anchor="nw")
    showButton = customtkinter.CTkButton(layoutPannel, text="Display layout")
    CreateToolTip(showButton, text="The layout demonstration is\nunder development.")
    showButton.place(relx=0.5, rely=0.1, anchor="center")
"""


def constructDependencyFiles(cgraflow_basepath, standard_module_name, test_platform_name, verilog_srcfile_path,
                             mk_sdc_file_path, orfs_basePath):
    # Finds the target RTL design and transforms the format.
    files = os.listdir(cgraflow_basepath + "/build/verilog")
    for f in files:
        # Finds the generated verilog file.
        if f == "design.v":
            os.chdir(cgraflow_basepath + "/build/verilog")
            # Manually copies design.v to design.sv to make sv2v work normally.
            logging.info("Renaming the system verilog file generated by PyMTL3.")
            subprocess.run(["cp design.v design.sv"], shell=True, encoding="utf-8")
            # Uses sv2v to convert system verilog to verilg.
            logging.info("Converting the system verilog file to verilog file.")
            subprocess.run(["../../tools/sv2v/bin/sv2v --write=adjacent " + "design.sv"], shell=True, encoding="utf-8")
            # Changes the top module name in design.v to standard_module_name.
            logging.info("Standardizing the top module name in verilog file.")
            contents = ""
            with open("design.v", "r", encoding="utf-8") as lines:
                for line in lines:
                    if standard_module_name in line:
                        line = "module " + standard_module_name + " ("
                    contents += line
            with open(standard_module_name + ".v", "w", encoding="utf-8") as newFile:
                newFile.write(contents)
            break

    # Makes directories and copies CgraTemplateRTL.v, the pre-defined config.mk, and constraint.sdc to their respective directories.
    global constraintFilePath, configFilePath
    os.chdir(orfs_basePath)
    subprocess.run(["mkdir -p " + verilog_srcfile_path], shell=True, encoding="utf-8")
    subprocess.run(
        ["cp " + cgraflow_basepath + "/build/verilog/" + standard_module_name + ".v " + verilog_srcfile_path],
        shell=True, encoding="utf-8")
    subprocess.run(["mkdir -p " + mk_sdc_file_path], shell=True, encoding="utf-8")
    subprocess.run(["cp " + constraintFilePath + " " + mk_sdc_file_path], shell=True, encoding="utf-8")
    subprocess.run(["cp " + configFilePath + " " + mk_sdc_file_path], shell=True, encoding="utf-8")

    # Updates process within the config.mk to the user selected one.
    with open(mk_sdc_file_path + "config.mk", 'r') as file:
        # Reads all lines within the file.
        lines = file.readlines()
        # Modifies the first line, replaces the PLATFORM with the user selected process technology.
        lines[0] = "export PLATFORM         = " + test_platform_name + "\n"
    with open(mk_sdc_file_path + "config.mk", 'w') as file:
        # Writes the updated content back to config.mk.
        file.writelines(lines)


def runOpenRoad(mk_sdc_file_path):
    # Runs the test module from RTL to GDSII.
    subprocess.run(["make DESIGN_CONFIG=./" + mk_sdc_file_path + "config.mk"], shell=True, encoding="utf-8")


def clickRTL2Layout():
    global constraintFilePath, configFilePath
    standard_module_name = "CgraTemplateRTL"
    cgraflow_basepath = os.path.dirname(os.path.abspath(__file__))
    test_platform_name = processOptions.get()
    logging.info(f"Test platform is {test_platform_name}")
    orfs_basePath = cgraflow_basepath + "/tools/OpenROAD-flow-scripts/flow/"
    layout_path = orfs_basePath + f"reports/{test_platform_name}/{standard_module_name}/base/" + "final_all.webp"
    odb_path = orfs_basePath + "results/" + test_platform_name + "/" + standard_module_name + "/base/6_final.odb"
    cmd_path = orfs_basePath + "cmd.tcl"
    verilog_srcfile_path = "designs/src/" + standard_module_name + "/"
    mk_sdc_file_path = "designs/" + test_platform_name + "/" + standard_module_name + "/"

    if constraintFilePath == "" or configFilePath == "":
        tkinter.messagebox.showerror(title="Missing files for RTL->Layout",
                                     message="constraint.sdc and config.mk need to be selected first.")
        return

    # Checks if layout.png of target design already exists.
    # If yes, directly shows.
    if os.path.exists(layout_path):
        display_layout_image(layout_path)
    # If not, runs the design from RTL to GDSII and saves layout.png, finally shows.
    else:
        # Generates all dependency files for openroad.
        constructDependencyFiles(cgraflow_basepath, standard_module_name, test_platform_name,
                                 verilog_srcfile_path, mk_sdc_file_path, orfs_basePath)
        # Runs openroad.
        runOpenRoad(mk_sdc_file_path)
        # Shows the layout image on CGRA-Flow GUI.
        display_layout_image(layout_path)


def clickSelectConstraintFile(event):
    global constraintFilePath
    constraintFilePath = fd.askopenfilename(title="Chooses constraint.sdc for synthesis.", initialdir="../docker",
                                            filetypes=(("SDC file", "*.sdc"),))
    widgets["constraintPathEntry"].delete(0, tkinter.END)
    widgets["constraintPathEntry"].insert(0, constraintFilePath)
    logging.info(constraintFilePath)


def clickSelectConfigFile(event):
    global configFilePath
    configFilePath = fd.askopenfilename(title="Chooses config.mk for OpenRoad.", initialdir="../docker",
                                        filetypes=(("MK file", "*.mk"),))
    widgets["configPathEntry"].delete(0, tkinter.END)
    widgets["configPathEntry"].insert(0, configFilePath)
    logging.info(configFilePath)


def display_layout_image(image_path):
    layoutImage = customtkinter.CTkImage(light_image=Image.open(image_path),
                                         dark_image=Image.open(image_path),
                                         size=(320, 320))
    layoutLabel.configure(image=layoutImage)


def create_mapping_pannel(master):
    # mappingPannel = tkinter.LabelFrame(master, text='Mapping', bd=BORDER, relief='groove')
    mappingPannel = customtkinter.CTkFrame(master)
    # mappingPannel.grid(row=1, column=1, rowspan=1, columnspan=3, padx=(0, 5), pady=(5, 0), sticky="nsew")
    mappingPannelLabel = customtkinter.CTkLabel(mappingPannel, text='Mapping ',
                                                # width=100,
                                                font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                           weight="bold"))
    mappingPannelLabel.pack(anchor="w", padx=(5, 0))
    mappingCanvas = customtkinter.CTkCanvas(mappingPannel, bg=CANVAS_BG_COLOR, bd=0, highlightthickness=0)
    widgets["mappingCanvas"] = mappingCanvas
    hbar = customtkinter.CTkScrollbar(mappingPannel, orientation="horizontal", command=mappingCanvas.xview)
    hbar.pack(side="bottom", fill="x")
    mappingCanvas.config(xscrollcommand=hbar.set)
    vbar = customtkinter.CTkScrollbar(mappingPannel, orientation="vertical", command=mappingCanvas.yview)
    vbar.pack(side=tkinter.RIGHT, fill="y")
    mappingCanvas.config(yscrollcommand=vbar.set)
    mappingCanvas.pack(side="top", fill="both", expand=True)

    return mappingPannel


def create_kernel_pannel(master):
    # kernelPannel = tkinter.LabelFrame(master, text="Kernel", bd=BORDER, relief='groove')
    kernelPannel = customtkinter.CTkFrame(master, width=280)
    kernelPannel.grid_propagate(0)
    # kernelPannel.grid(row=1, column=0, padx=(0, 5), pady=(5, 0), sticky="nsew")
    for row in range(14):
        kernelPannel.grid_rowconfigure(row, weight=1)
    kernelPannel.grid_rowconfigure(5, weight=2)
    kernelPannel.grid_columnconfigure(0, weight=3)
    kernelPannel.grid_columnconfigure(1, weight=2)
    kernelPannel.grid_columnconfigure(2, weight=2)
    kernelPannel.grid_columnconfigure(3, weight=1)

    kernelPannellLabel = customtkinter.CTkLabel(kernelPannel, text='Kernel ',
                                                # width=100,
                                                font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                           weight="bold"))
    kernelPannellLabel.grid(row=0, column=0, padx=(5, 0), sticky="wn")

    selectAppLabel = customtkinter.CTkLabel(kernelPannel, text=" Application:")
    selectAppLabel.grid(row=1, column=0)

    appPathEntry = customtkinter.CTkEntry(kernelPannel)
    widgets["appPathEntry"] = appPathEntry
    appPathEntry.grid(row=1, column=1)
    appPathEntry.bind("<Button-1>", clickSelectApp)

    compileAppButton = customtkinter.CTkButton(kernelPannel, text=" Compile app  ", command=clickCompileApp)
    compileAppButton.grid(row=1, column=2, padx=5)

    compileAppShow = customtkinter.CTkLabel(kernelPannel, text=" IDLE")
    compileAppShow.grid(row=1, column=3)
    widgets["compileAppShow"] = compileAppShow

    kernelNameLabel = customtkinter.CTkLabel(kernelPannel, text=" Kernel name:")
    kernelNameLabel.grid(row=2, column=0)

    tempOptions = ["Not selected yet"]
    # kernelNameMenu = tkinter.OptionMenu(kernelPannel, kernelOptions, *tempOptions)
    kernelNameMenu = customtkinter.CTkOptionMenu(kernelPannel, variable=kernelOptions, values=tempOptions)
    kernelOptions.trace("w", clickKernelMenu)
    widgets["kernelNameMenu"] = kernelNameMenu
    widgets["kernelPannel"] = kernelPannel
    kernelNameMenu.grid(row=2, column=1)

    generateDFGButton = customtkinter.CTkButton(kernelPannel, text="Generate DFG", command=clickShowDFG)
    generateDFGButton.grid(row=2, column=2, padx=5)

    generateDFGShow = customtkinter.CTkLabel(kernelPannel, text=" IDLE")
    generateDFGShow.grid(row=2, column=3, sticky="ew")
    widgets["generateDFGShow"] = generateDFGShow

    dfgPannel = customtkinter.CTkFrame(kernelPannel)
    dfgPannel.grid(row=3, column=0, rowspan=11, columnspan=2, padx=(0, 5), pady=(5, 0), sticky="nsew")
    dfgPannelLabel = customtkinter.CTkLabel(dfgPannel, text='Data-Flow Graph ',
                                            font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                       weight="bold"))
    dfgPannelLabel.pack(anchor="w", padx=(5, 0))
    dfgLabel = customtkinter.CTkLabel(dfgPannel, text="")
    widgets["dfgLabel"] = dfgLabel
    dfgLabel.pack()

    recMIILabel = customtkinter.CTkLabel(kernelPannel, text=" RecMII: ")
    recMIILabel.grid(row=3, column=2, sticky="nsew")
    recMIIEntry = customtkinter.CTkEntry(kernelPannel, justify=tkinter.CENTER)
    widgets["recMIIEntry"] = recMIIEntry
    recMIIEntry.insert(0, "0")
    recMIIEntry.grid(row=3, column=3)
    resMIILabel = customtkinter.CTkLabel(kernelPannel, text=" ResMII: ")
    resMIILabel.grid(row=4, column=2, sticky="nsew")
    resMIIEntry = customtkinter.CTkEntry(kernelPannel, justify=tkinter.CENTER)
    widgets["resMIIEntry"] = resMIIEntry
    resMIIEntry.insert(0, "0")
    resMIIEntry.grid(row=4, column=3)

    mappingAlgoPannel = customtkinter.CTkFrame(kernelPannel)
    mappingAlgoPannel.grid(row=5, column=2, rowspan=3, columnspan=2, pady=(5, 10), sticky="nsew")
    for row in range(2):
        mappingAlgoPannel.grid_rowconfigure(row, weight=1)
    mappingAlgoPannel.grid_columnconfigure(0, weight=1)
    mappingAlgoPannel.grid_columnconfigure(1, weight=1)
    # mappingOptionLabel = customtkinter.CTkLabel(mappingAlgoPannel, text="Mapping algo:")
    mappingOptionLabel = customtkinter.CTkLabel(mappingAlgoPannel, text='Mapping Algorithm',
                                                font=customtkinter.CTkFont(size=FRAME_LABEL_FONT_SIZE,
                                                                           weight="bold"))
    mappingOptionLabel.grid(row=0, column=0, columnspan=2)
    heuristicRadioButton = customtkinter.CTkRadioButton(mappingAlgoPannel, text="Heuristic",
                                                        variable=mappingAlgoCheckVar, value=0)
    widgets["heuristicRadioButton"] = heuristicRadioButton
    heuristicRadioButton.grid(row=1, column=0, pady=(0, 5), sticky="nsew")
    exhaustiveRadioButton = customtkinter.CTkRadioButton(mappingAlgoPannel, text="Exhaustive",
                                                         variable=mappingAlgoCheckVar, value=1)
    widgets["exhaustiveRadioButton"] = exhaustiveRadioButton
    exhaustiveRadioButton.grid(row=1, column=1, pady=(0, 5), sticky="nsew")

    tarCgraIdLabel = customtkinter.CTkLabel(kernelPannel, text=" Target CGRA id: ")
    tarCgraIdLabel.grid(row=8, column=2)

    targetCgraIdOptions = ["0", "1", "2", "3"]
    targetCgraIdVariable = tkinter.StringVar(kernelPannel)
    targetCgraIdVariable.set(targetCgraIdOptions[0])
    targetCgraIdOptionMenu = customtkinter.CTkOptionMenu(kernelPannel, variable=targetCgraIdVariable,
                                                         values=targetCgraIdOptions)
    targetCgraIdOptionMenu.grid(row=8, column=3)

    mapDFGButton = customtkinter.CTkButton(kernelPannel, text="Map DFG", command=clickMapDFG, )
    mapDFGButton.grid(row=9, column=2, columnspan=2, sticky="new")
    terminateMapButton = customtkinter.CTkButton(kernelPannel, text="Terminate", command=clickTerminateMapping)
    terminateMapButton.grid(row=10, column=2, columnspan=2, sticky="new")

    mapSecLabel = customtkinter.CTkLabel(kernelPannel, text="Time (s): ")
    mapSecLabel.grid(row=11, column=2)
    mapTimeEntry = customtkinter.CTkEntry(kernelPannel, justify=tkinter.CENTER)
    widgets["mapTimeEntry"] = mapTimeEntry
    mapTimeEntry.insert(0, "0")
    mapTimeEntry.grid(row=11, column=3)
    mapIILabel = customtkinter.CTkLabel(kernelPannel, text=" Map II: ")
    mapIILabel.grid(row=12, column=2)
    mapIIEntry = customtkinter.CTkEntry(kernelPannel, justify=tkinter.CENTER)
    widgets["mapIIEntry"] = mapIIEntry
    mapIIEntry.insert(0, "0")
    mapIIEntry.grid(row=12, column=3)

    speedupLabel = customtkinter.CTkLabel(kernelPannel, text="Speedup: ")
    speedupLabel.grid(row=13, column=2)
    CreateToolTip(speedupLabel,
                  text="The speedup is the improvement of\nthe execution cycles with respect to\na single-issue in-order CPU.")
    mapSpeedupEntry = customtkinter.CTkEntry(kernelPannel, justify=tkinter.CENTER)
    widgets["mapSpeedupEntry"] = mapSpeedupEntry
    mapSpeedupEntry.insert(0, "0")
    mapSpeedupEntry.grid(row=13, column=3)

    return kernelPannel

# Performs a perodical checks on whether the UI components are drawn into the screen or not.
def check_ui_ready(
        master: customtkinter.CTk,
        multiCgraPanel: customtkinter.CTkFrame,
        multiCgraConfigPanel: customtkinter.CTkFrame,
        kernel_panel: customtkinter.CTkFrame,
        mapping_panel: customtkinter.CTkFrame,
        cgra_panel: customtkinter.CTkFrame,
        param_panel: customtkinter.CTkFrame,
        data_panel: customtkinter.CTkFrame,
        layout_panel: customtkinter.CTkFrame,
        chat_panel: customtkinter.CTkFrame,
        window: customtkinter.CTkToplevel,
):
    panels = [
        multiCgraPanel,
        multiCgraConfigPanel,
        kernel_panel,
        mapping_panel,
        cgra_panel,
        param_panel,
        data_panel,
        layout_panel,
        chat_panel,
    ]

    if all(panel.winfo_ismapped() for panel in panels):
        master.after(100, window.destroy)
    else:
        master.after(200, lambda: check_ui_ready(master, *panels, window))


# Display all the UI components by calling grid() and start a periodical checks on when they are ready.
def show_all_ui(master: customtkinter.CTk, window: customtkinter.CTkToplevel):
    multiCgraConfigPanel = create_multi_cgra_config_panel(master)
    kernelPannel = create_kernel_pannel(master)
    mappingPannel = create_mapping_pannel(master)
    cgraPannel = create_cgra_pannel(master, selectedCgraParam.rows, selectedCgraParam.columns)
    multiCgraPanel = create_multi_cgra_panel(master, multiCgraParam.rows, multiCgraParam.cols)
    paramPannel = create_param_pannel(master)
    dataPannel = create_test_pannel(master)
    layoutPannel = create_layout_pannel(master)
    chatPanel = create_chat_panel(master)
    multiCgraPanel.grid(row=0, column=0, padx=(0, 5), sticky="nsew")
    multiCgraConfigPanel.grid(row=0, column=1, sticky="nsew")
    kernelPannel.grid(row=1, column=0, padx=(0, 5), pady=(5, 0), sticky="nsew")
    mappingPannel.grid(row=1, column=1, rowspan=1, columnspan=3, padx=(0, 5), pady=(5, 0), sticky="nsew")
    # paramPannel.grid(row=0, column=4, columnspan=2, sticky="nsew")
    dataPannel.grid(row=1, column=4, pady=(5, 0), sticky="nsew")
    layoutPannel.grid(row=1, column=5, padx=(5, 0), pady=(5, 0), sticky="nsew")
    chatPanel.grid(row=0, column=6, rowspan=2, padx=(5, 0), pady=(0, 0), sticky="nsew")
    # Once kernel is drawn stop the check loop after 100ms.
    if (kernelPannel.winfo_ismapped()):
        master.after(100, window.destroy())
    # Keeps checking if UI components are drawn in every 2 seconds.
    else:
        master.after(2000,
                     lambda: check_ui_ready(master, multiCgraPanel, multiCgraConfigPanel, kernelPannel, mappingPannel,
                                            cgraPannel, paramPannel, dataPannel, layoutPannel, chatPanel, window))


# paramPadPosX = GRID_WIDTH + MEM_WIDTH + LINK_LENGTH + INTERVAL * 3
# paramPadWidth = 270
# scriptPadPosX = paramPadPosX + paramPadWidth + INTERVAL
# scriptPadWidth = 300
# layoutPadPosX = scriptPadPosX + scriptPadWidth + INTERVAL
# layoutPadWidth = 300
# layoutPadHeight = GRID_HEIGHT
TILE_HEIGHT = 70
TILE_WIDTH = 70
LINK_LENGTH = 40
GRID_WIDTH = (TILE_WIDTH + LINK_LENGTH) * COLS - LINK_LENGTH
GRID_HEIGHT = (TILE_HEIGHT + LINK_LENGTH) * ROWS - LINK_LENGTH

# Sets size first to avoid window keep resizing during loading.
w, h = master.winfo_screenwidth(), master.winfo_screenheight()
master.geometry("%dx%d" % (w - 10, h - 70))
master.geometry("+%d+%d" % (0, 0))

main_frame = customtkinter.CTkFrame(master)

overlay = customtkinter.CTkToplevel(master)
overlay.geometry("%dx%d" % (w - 10, h - 70))
overlay.transient(master)
overlay.wait_visibility()
overlay.grab_set()

loading_label = customtkinter.CTkLabel(overlay, text="Loading...", font=("Arial", 24, "bold"))
loading_label.place(relx=0.5, rely=0.4, anchor="center")

progress = customtkinter.CTkProgressBar(overlay)
progress.place(relx=0.5, rely=0.5, anchor="center")
progress.start()

# Adds other UI components in a separate thread.
threading.Thread(target=show_all_ui(master, overlay), daemon=True).start()

# # kernel
# create_kernel_pannel(master)
# # mapping
# create_mapping_pannel(master)
# # multi cgra
# create_multi_cgra_panel(master, CGRA_ROWS, CGRA_COLS)
# # multi cgra config
# create_multi_cgra_config_panel(master)
# # cgra
# create_cgra_pannel(master, ROWS, COLS)
# # configuration
# create_param_pannel(master)
# # verification
# create_test_pannel(master)
# # layout
# create_layout_pannel(master)
# The width and height of the entire window
default_width = 1950
default_height = 1000
window_size(master, default_width, default_height)
# master.grid_rowconfigure(0, weight=1)
master.grid_rowconfigure(1, weight=2)
master.grid_columnconfigure(0, weight=5)
master.grid_columnconfigure(1, weight=1)
master.grid_columnconfigure(2, weight=5)
master.grid_columnconfigure(3, weight=1)
master.grid_columnconfigure(4, weight=1)
master.grid_columnconfigure(5, weight=1)
master.grid_columnconfigure(6, weight=1)  # AI Chat panel column
# logging.info(master.winfo_width())
# logging.info(master.winfo_height())
# w, h = master.winfo_screenwidth(), master.winfo_screenheight()
master.geometry("%dx%d" % (w - 10, h - 70))
master.geometry("+%d+%d" % (0, 0))
master.mainloop()