# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
#
# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
# property and proprietary rights in and to this material, related
# documentation and any modifications thereto. Any use, reproduction,
# disclosure or distribution of this material and related documentation
# without an express license agreement from NVIDIA CORPORATION or
# its affiliates is strictly prohibited.

from tkinter.ttk import Frame

from ..utils.datacenter import data_center
from ..utils.layoutmanager import fill_parent, frame_style, padding
from .components import (
    CPUFrame,
    InfoFrame,
    GPUFrame,
    EMCFrame,
    EngineFrame,
    SensorFrame,
    PowerFrame,
    FanFrame,
    DiskFrame,
    RecordFrame,
)

class MainScreen(Frame):
    def __init__(self, master=None, **kwargs):
        super().__init__(master, **kwargs)
        self.create_widgets()
        self.attach_observers()
        self.manage_layout()
        fill_parent(self)

    def create_widgets(self):
        self.info_f = InfoFrame(self, **frame_style)
        self.cpu_f = CPUFrame(self, **frame_style,
                              cpu_nums=data_center.cpu_nums)
        self.gpu_f = GPUFrame(self, **frame_style,
                              igpu_nums=data_center.igpu_nums)
        self.emc_f = EMCFrame(self, **frame_style)
        self.engines_f = EngineFrame(self, **frame_style)
        self.sensor_f = SensorFrame(self, **frame_style)
        self.power_f = PowerFrame(self, **frame_style)
        self.fan_f = FanFrame(self, **frame_style)
        self.disk_f = DiskFrame(self, **frame_style)
        self.record_f = RecordFrame(self, **frame_style)

    def attach_observers(self):
        # These frames need to be notified when the power data is updated,
        # so they are regarded as observers of the data center
        data_center.attach(self.info_f)
        data_center.attach(self.cpu_f)
        data_center.attach(self.gpu_f)
        data_center.attach(self.emc_f)
        data_center.attach(self.engines_f)
        data_center.attach(self.sensor_f)
        data_center.attach(self.power_f)
        data_center.attach(self.fan_f)
        data_center.attach(self.disk_f)
        data_center.attach(self.record_f)

    def manage_layout(self):
        heading_row = 1  # if a frame has heading, it will occupy 1 row

        # Predefine how many rows are there in each frame
        info_rows = 1
        cpu_rows = heading_row + data_center.cpu_nums
        gpu_rows = heading_row + data_center.igpu_nums  # TODO: consider dgpu
        emc_rows = heading_row + 3
        engine_rows = heading_row + self.engines_f.max_engines_per_col
        sensor_rows = heading_row + data_center.sensor_nums
        power_rows = heading_row + data_center.rail_nums
        fan_rows = 4
        disk_rows = 1
        record_rows = 1

        # Top part (at top side of the main screen)
        next_starting_row = 0
        self.info_f.grid(row=next_starting_row,
                         column=0,
                         rowspan=info_rows,
                         columnspan=6,
                         sticky="WENS",
                         **padding)

        # Left part (at left side of the main screen)
        next_starting_row += info_rows
        self.cpu_f.grid(row=next_starting_row,
                        column=0,
                        rowspan=cpu_rows,
                        columnspan=3,
                        sticky="WENS",
                        **padding)
        next_starting_row += cpu_rows
        self.gpu_f.grid(row=next_starting_row,
                        column=0,
                        rowspan=gpu_rows,
                        columnspan=3,
                        sticky="WENS",
                        **padding)
        next_starting_row += gpu_rows
        self.emc_f.grid(row=next_starting_row,
                        column=0,
                        rowspan=emc_rows,
                        columnspan=3,
                        sticky="WENS",
                        **padding)
        next_starting_row += emc_rows
        self.engines_f.grid(row=next_starting_row,
                            column=0,
                            rowspan=engine_rows,
                            columnspan=3,
                            sticky="WENS",
                            **padding)
        left_part_total_rows = next_starting_row + engine_rows - 1

        # Right part (at right side of the main screen)
        next_starting_row = info_rows
        self.sensor_f.grid(row=next_starting_row,
                           column=3,
                           rowspan=sensor_rows,
                           columnspan=3,
                           sticky="WENS",
                           **padding)
        next_starting_row += sensor_rows
        self.power_f.grid(row=next_starting_row,
                          column=3,
                          rowspan=power_rows,
                          columnspan=3,
                          sticky="WENS",
                          **padding)
        next_starting_row += power_rows
        self.fan_f.grid(row=next_starting_row,
                        column=3,
                        rowspan=fan_rows,
                        columnspan=3,
                        sticky="WENS",
                        **padding)
        next_starting_row += fan_rows
        self.disk_f.grid(row=next_starting_row,
                         column=3,
                         rowspan=disk_rows,
                         columnspan=3,
                         sticky="WENS",
                         **padding)
        next_starting_row += disk_rows

        # Bottom part (at bottom side of the main screen)
        self.record_f.grid(row=max(next_starting_row, left_part_total_rows + 1),
                           column=0,
                           rowspan=record_rows,
                           columnspan=6,
                           sticky="WENS",
                           **padding)