# ------------------------------------------------------------------------------
# Copyright (c) 2022, Arm Limited. All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
#
# ------------------------------------------------------------------------------

import sqlite3
import curses
import curses.textpad

class UI(object):
    """
    Class UI is used to show the data in the terminal with library curses. It
    contains two main diffrent functions, one is to control the UI and show the
    message in the terminal, the other is to search the information and then
    transform it into a string varible called items[]. This can be showed or
    exported as a plaintext. These functions to fill items[] are PUBLIC.

    - Methods:
      - UI().run()              - Run the UI in terminal.
      - UI.draw_<symbol>_page() - Get the information of specific symbol
      - UI.open_db()            - Open database.

    - Variables:
      - UI().items              - The result searched from database.
      - UI().armcc              - ARMCLANG option.
      - UI().gnuarm             - GNUARM option.
      - UI().con                - Database handler.
      - UI().function_name      - Specific function name.
      - UI().data_name          - Specific data name.
      - UI().section_name       - Specific section name.
      - UI().library_name       - Specific library name.
      - UI().obj_file           - Specific object file name.
      - UI().db_file            - Database file.
      - UI().sort               - Database list order: size, name and so on.
      - UI().order              - Database sort order: DESC and ASC.
    """

    def __init__(self):
        """
        Initialize variables.
        """
        self.function_name = ""
        self.data_name = ""
        self.section_name = ""
        self.library_name = ""
        self.obj_file = ""
        self.gnuarm = False
        self.armcc = False
        self.items = []
        self.db_file = ""
        self.sort = "size"
        self.order = "DESC"

        self.__window = None
        self.__width = 0
        self.__height = 0
        self.__menu_depth = 0
        self.__detail = 0
        self.__section_detail = 0
        self.__UP = -1
        self.__DOWN = 1
        self.__line1 = "─" * 128
        self.__line2 = "-" * 128
        self.__cmd_file="Enter the file name:"
        self.__cmd_func="Enter the function name:"
        self.__cmd_data="Enter the data name:"

    def open_db(self):
        self.con = sqlite3.connect(self.db_file)
        self.__cur = self.con.cursor()
        cursor = self.__cur.execute("select * from Compiler")
        for row in cursor:
            compiler = row[1]
            if compiler == 1:
                self.gnuarm = True
            elif compiler == 0:
                self.armcc = True

    def __init_curses(self):
        """
        Setup the curses
        """
        self.__window = curses.initscr()
        self.__window.keypad(True)

        curses.noecho()
        curses.cbreak()
        curses.curs_set(False)

        curses.start_color()
        curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
        curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_WHITE)

        self.__current = curses.color_pair(2)
        self.__height, self.__width = self.__window.getmaxyx()

        self.__max_lines = curses.LINES - 1
        self.__top = 0

        self.__bottom = len(self.items)
        self.__current = 0
        self.__current_x = 0

    def __input_stream(self):
        """
        Waiting an input and run a proper method according to type of input
        """
        while True:
            self.__display()

            ch = self.__window.getch()
            if ch == curses.KEY_UP:
                self.__scroll(self.__UP)
            elif ch == curses.KEY_DOWN:
                self.__scroll(self.__DOWN)
            elif ch == curses.KEY_LEFT:
                self.__current_x = max(self.__current_x - 1, 0)
            elif ch == curses.KEY_RIGHT:
                self.__current_x = self.__current_x + 1
            elif ch ==  ord('q') or ch == ord('Q'):
                """
                If press 'q' or 'Q', escape this page
                """
                if self.__menu_depth == 0:
                    break
                self.__menu_depth = max(self.__menu_depth - 1, 0)
                self.__draw_page()
            elif ch == 10:
                """
                If press ENTER, get into next page if it exists
                """
                self.__get_menu_choose()
                self.__menu_depth = self.__menu_depth + 1
                self.__draw_page()
            elif ch == 58:
                """
                If press ':', get target name form input line to search
                functions or data
                """
                if self.__menu_depth == 1:
                    if self.__detail == 3:
                        self.draw_function_page(self.__get_input_line_msg(self.__cmd_func))
                    if self.__detail == 4:
                        self.draw_data_page(self.__get_input_line_msg(self.__cmd_data))
            elif ch == ord('s') or ch == ord('S'):
                """
                If press 's' or 'S', save to file
                """
                self.__save_file(self.__get_input_line_msg(self.__cmd_file))

    def __get_input_line_msg(self, cmd):
        """
        Get message from input line.
        """
        self.__window.addstr(self.__height - 1, 0, cmd, curses.color_pair(2))
        self.input_line = curses.newwin(1, curses.COLS - 2 - len(cmd), curses.LINES-1, len(cmd) + 1)
        self.input_box = curses.textpad.Textbox(self.input_line)
        self.__window.refresh()
        self.input_box.edit()
        ret = self.input_box.gather()[:len(self.input_box.gather())-1]
        self.__display()
        self.input_line.clear()
        return ret

    def __save_file(self, output_file_name):
        """
        Save to files
        """
        fo = open(output_file_name + '.txt', "w")
        for s in self.items:
            fo.write(s + '\n')
        fo.close()

    def __scroll(self, direction):
        """
        Scrolling the window when pressing up/down arrow keys
        """
        next_line = self.__current + direction
        if (direction == self.__UP) and (self.__top > 0 and self.__current == 0):
            self.__top += direction
            return
        if (direction == self.__DOWN) and (next_line == self.__max_lines) and \
                (self.__top + self.__max_lines < self.__bottom):
            self.__top += direction
            return
        if (direction == self.__UP) and (self.__top > 0 or self.__current > 0):
            self.__current = next_line
            return
        if (direction == self.__DOWN) and (next_line < self.__max_lines) and \
                (self.__top + next_line < self.__bottom):
            self.__current = next_line
            return

    def __display(self):
        """
        Display the items on window
        """
        self.__window.erase()
        for idx, item in enumerate(self.items[self.__top:self.__top + self.__max_lines]):
            if idx == self.__current:
                self.__window.addstr(idx, 0, item[self.__current_x:self.__current_x + self.__width], curses.color_pair(2))
            else:
                self.__window.addstr(idx, 0, item[self.__current_x:self.__current_x + self.__width], curses.color_pair(1))
        self.__window.refresh()

    def __draw_page(self):
        """
        Draw different page with menu_depth, detail and section_detail.
        """
        if self.__menu_depth == 0:
            self.__draw_welcome_page()
        elif self.__menu_depth == 1:
            if self.__detail == 1:
                self.draw_summary_page()
            if self.__detail == 2:
                self.draw_section_page()
            if self.__detail == 3:
                self.draw_function_page("")
            if self.__detail == 4:
                self.draw_data_page("")
            if self.__detail == 5:
                self.draw_library_page()
            if self.__detail == 6:
                self.draw_obj_page()
        elif self.__menu_depth == 2:
            if self.__detail == 2:
                self.draw_section_detail_page()
            if self.__detail == 3:
                self.draw_function_detail_page()
            if self.__detail == 4:
                self.draw_data_detail_page()
            if self.__detail == 5:
                self.draw_library_detail_page()
            if self.__detail == 6:
                self.draw_obj_detail_page()
        elif self.__menu_depth == 3 and self.__detail == 2:
            """
            Draw section detail menu, here self.__detail is 2
            """
            if self.__section_detail == 1:
                self.draw_section_lib()
            if self.__section_detail == 2:
                self.draw_section_func()
            if self.__section_detail == 3:
                self.draw_section_data()
        elif self.__menu_depth == 4:
            """
            Only section detail menu can move to menu depth 5, here function
            detail and data detail are also supported.
            """
            if self.__section_detail == 2:
                self.draw_function_detail_page()
            if self.__section_detail == 3:
                self.draw_data_detail_page()

        self.__bottom = len(self.items)
        self.__current = 0
        self.__current_x = 0
        self.__top = 0

    def __get_menu_choose(self):
        """
        Get options from menus or specific objects like function, data, library
        or object files.
        """

        """
        First page, menu_depth = 1
            =============================
            Current file: tfm_s.axf
            1. Summary Info          -->
            2. Section Module        -->
            3. Function detail       -->
            4. Data detail           -->
            5. Library Summary       -->
            6. Object files Summary  -->
            =============================
        It will change the self.__detail's value in range 1 - 6
        """
        if self.__menu_depth == 0:
            if self.__current + self.__top > 0:
                self.__detail = self.__current
            else:
                """
                Except first line
                """
                self.__menu_depth = self.__menu_depth - 1
        if self.__menu_depth == 1:
            if self.__current + self.__top > 0:
                if self.__detail == 2:
                    """
                    Get section name which will be used to draw its detail page
                    in __draw_page() function.
                    """
                    self.section_name = self.items[self.__top + self.__current].split()[0]
                elif self.__detail == 3:
                    """
                    Get function name and its object file to avoid same name
                    situation. Function name will be used to draw its detail
                    page in __draw_page() function.
                    """
                    self.function_name = self.items[self.__top + self.__current].split()[0]
                    self.obj_file = self.items[self.__top + self.__current].split()[4]
                elif self.__detail == 4:
                    """
                    Get data name and its object file name to avoid same name
                    situation. Data name will be used to draw its detail page in
                    __draw_page() function.
                    """
                    self.data_name = self.items[self.__top + self.__current].split()[0]
                    self.obj_file = self.items[self.__top + self.__current].split()[5]
                elif self.__detail == 5:
                    """
                    Get library name which will be used to draw its detail page
                    in __draw_page() function.
                    """
                    self.library_name = self.items[self.__top + self.__current].split()[0]
                elif self.__detail == 6:
                    """
                    Get object file name which will be used to draw its detail
                    page in __draw_page() function.
                    """
                    self.obj_file = self.items[self.__top + self.__current].split()[0]
                else:
                    """
                    Other invalid choose will not change menu depth.
                    """
                    self.__menu_depth = self.__menu_depth - 1
            else:
                """
                Except first line
                """
                self.__menu_depth = self.__menu_depth - 1
        """
        Section detail page, menu_depth = 1
            =============================
            Name :TFM_UNPRIV_CODE           Size :155544
            1. Summary           -->
            2. Function          -->
            3. Data              -->
            =============================
        It will change the self.__section_detail's value in range 1 - 3
        """
        if self.__menu_depth == 2:
            if self.__current + self.__top > 0:
                if self.__detail == 2:
                    self.__section_detail = self.__current
                else:
                    self.__menu_depth = self.__menu_depth - 1
            else:
                self.__menu_depth = self.__menu_depth - 1
        if self.__menu_depth == 3:
            if self.__current + self.__top > 0:
                if self.__section_detail == 2:
                    self.function_name = self.items[self.__top + self.__current].split()[0]
                    self.obj_file = self.items[self.__top + self.__current].split()[4]
                elif self.__section_detail == 3:
                    self.data_name = self.items[self.__top + self.__current].split()[0]
                    self.obj_file = self.items[self.__top + self.__current].split()[5]
                else:
                    self.__menu_depth = self.__menu_depth - 1
            else:
                self.__menu_depth = self.__menu_depth - 1
        if self.__menu_depth == 4:
            self.__menu_depth = self.__menu_depth - 1

    def __draw_welcome_page(self):
        self.items = ["Code Size Analysis Tool for Map File",
                      "1. Summary Info          -->",
                      "2. Section Module        -->",
                      "3. Function detail       -->",
                      "4. Data detail           -->",
                      "5. Library Summary       -->",
                      "6. Object files Summary  -->"]

    def draw_summary_page(self):
        """
        Get summary info from database and save into self.items.
        """
        cursor = self.__cur.execute("select * from Summary")
        if self.gnuarm:
            for row in cursor:
                self.items = [self.__line1,
                              "Total usage(include all symbols and \"fill or pad\"):",
                              "Flash size\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[6], row[6]/1024),
                              "RAM size\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[7], row[7]/1024),
                              self.__line2,
                              "These data are collected from functions, stacks or arrays sizes without \"fill or pad\" part!",
                              "Text size\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[0], row[0]/1024),
                              "Read-only data\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[1], row[1]/1024),
                              "Read-write data\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[2], row[2]/1024),
                              "BSS data\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[3], row[3]/1024),
                              self.__line2,
                              "Some other unknown type symbols locate in flash or ram:",
                              "Total unknown type symbols in flash: {:<8}\t{:<4.2f}\tKB".
                              format(row[4], row[4]/1024),
                              "Total unknown type symbols in RAM  : {:<8}\t{:<4.2f}\tKB".
                              format(row[5], row[5]/1024),
                              self.__line1]
                break
        if self.armcc:
            for row in cursor:
                self.items = ["Code size\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[0], row[0]/1024),
                              "RO data\t\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[1], row[1]/1024),
                              "RW data\t\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[2], row[2]/1024),
                              "ZI data\t\t: {:<8}\t{:<4.2f}\tKB".
                              format(row[3], row[3]/1024),
                              "Flash size\t: {:<8}\t{:<4.2f}\tKB = Code + RO + RW".
                              format(row[6], row[6]/1024),
                              "RAM size\t: {:<8}\t{:<4.2f}\tKB = RW + ZI".
                              format(row[7], row[7]/1024)]
                break

    def draw_section_page(self):
        """
        Get section info from database and save into self.items.
        """
        self.items = ["{:<50}{:<16}{:<16}{:<16}".
                      format("Name", "Size", "Address", "PAD size")]

        cursor = self.__cur.execute("select * from Section ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<16}{:<16}{:<16}".
                              format(row[0], row[1], row[2], row[3]))

    def draw_section_detail_page(self):
        """
        Section detail page with a menu.
        """
        cursor = self.__cur.execute("select * from Section WHERE name = '{}'".
                                  format(self.section_name))
        for row in cursor:
            self.items = ["Name :{}\t\tSize :{}".
                          format(self.section_name, row[1]),
                          "1. Summary           -->",
                          "2. Function          -->",
                          "3. Data              -->"]
            break

    def draw_section_lib(self):
        lib_dict, obj_dict = {}, {}
        lib_list, obj_list = [], []
        exsit_no_lib_obj = False
        tmp_list = []
        colums_name = "{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".format(
            "Name", "Flash", "RAM", "Code", "RO data", "RW data", "ZI data", "Total")
        count = 0

        """
        Get detail information with functions and data from tables in database
        with a dictionary in python.
        """
        cursor = self.__cur.execute("select * from Function WHERE section = '{}' ORDER BY lib_file DESC".
                                  format(self.section_name))
        for row in cursor:
            lib_name = row[5]
            if lib_name in lib_dict.keys():
                lib_dict[lib_name]['Code'] += row[2]
            else:
                lib_dict[lib_name] = {'RO': 0, 'RW': 0,
                                      'Code': row[2], 'ZI': 0}

            obj_name = row[4]
            if obj_name in obj_dict.keys():
                obj_dict[obj_name]['Code'] += row[2]
            else:
                obj_dict[obj_name] = {'RO': 0, 'RW': 0,
                                      'Code': row[2], 'Lib': lib_name, 'ZI': 0}

        cursor = self.__cur.execute("select * from Data WHERE section = '{}' ORDER BY lib_file DESC".
                                  format(self.section_name))
        for row in cursor:
            lib_name = row[6]
            if lib_name in lib_dict.keys():
                lib_dict[lib_name][row[4]] += row[2]
            else:
                lib_dict[lib_name] = {'RO': 0, 'RW': 0, 'Code': 0, 'ZI': 0}
                lib_dict[lib_name][row[4]] = row[2]

            obj_name = row[5]
            if obj_name in obj_dict.keys():
                obj_dict[obj_name][row[4]] += row[2]
            else:
                obj_dict[obj_name] = {'RO': 0,  'RW': 0,
                                      'Code': 0, 'Lib': lib_name, 'ZI': 0}
                obj_dict[obj_name][row[4]] = row[2]

        """
        Transform the dictionary to a dictionary list in python and sort the
        elements with total size.
        """
        for s in lib_dict.keys():
            lib_list.append({'Name': s,
                             'RO': lib_dict[s]['RO'],
                             'RW': lib_dict[s]['RW'],
                             'Code': lib_dict[s]['Code'],
                             'ZI': lib_dict[s]['ZI']})
        lib_list = sorted(lib_list,
                          key=lambda i: i['RO'] + i['Code'] + i['RW'] + i['ZI'],
                          reverse=True)
        for s in obj_dict.keys():
            obj_list.append({'Name': s,
                             'RO': obj_dict[s]['RO'],
                             'RW': obj_dict[s]['RW'],
                             'Code': obj_dict[s]['Code'],
                             'Lib': obj_dict[s]['Lib'],
                             'ZI': obj_dict[s]['ZI']})
        obj_list = sorted(obj_list,
                          key=lambda i: i['RO'] + i['Code'] + i['RW'] + i['ZI'],
                          reverse=True)

        def sum_data(data_list):
            """
            Calculate the sum of libraries or object files, and implement total
            data line. It will be added into self.items.
            """
            ret = {'RO': 0, 'RW': 0, 'Code': 0, 'ZI': 0,
                   'Flash': 0, 'Ram': 0, 'Total': 0}
            if len(data_list) > 0:
                for s in data_list:
                    ret['Code'] += s['Code']
                    ret['RO'] += s['RO']
                    ret['RW'] += s['RW']
                    ret['ZI'] += s['ZI']
                    ret['Flash'] += s['Code'] + s['RO'] + s['RW']
                    ret['Ram'] += s['RW'] + s['ZI']
            ret['Total'] = ret['Flash'] + ret['ZI']
            self.items.append(self.__line2)
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format("Summary",
                                     ret['Flash'],
                                     ret['Ram'],
                                     ret['Code'],
                                     ret['RO'],
                                     ret['RW'],
                                     ret['ZI'],
                                     ret['Total']))
            self.items.append(self.__line1)
            return ret

        def insert_column_line(title):
            """
            Quickly insert column line.
            """
            self.items.append(title)
            self.items.append(self.__line2)
            self.items.append(colums_name)
            self.items.append(self.__line2)

        def quick_insert_data_line(s):
            """
            Quickly insert a single data line.
            """
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(s['Name'],
                                     s['Code'] + s['RO'] + s['RW'],
                                     s['RW'] + s['ZI'],
                                     s['Code'],
                                     s['RO'],
                                     s['RW'],
                                     s['ZI'],
                                     s['Code'] + s['RO'] + s['RW'] + s['ZI']))
        """
        Dump library information.
        """
        self.items = [self.__line1]
        insert_column_line(" " * ((128 - len("Section libraries"))//2) + "Section libraries")
        for s in lib_list:
            if s['Name'].find(".o") > 0:
                exsit_no_lib_obj = True
            else:
                tmp_list.append(s)
                quick_insert_data_line(s)
        sum_data(tmp_list)

        """
        Dump object file information.
        """
        insert_column_line(" " * ((128 - len("Section object files"))//2) + "Section object files")
        for s in obj_list:
            quick_insert_data_line(s)
        ret = sum_data(obj_list)
        total_flash_size, total_ram_size = ret['Flash'], ret['Ram']

        """
        Dump NOT-IN-LIBRARY object file information.
        """
        if exsit_no_lib_obj:
            insert_column_line(" " * ((128 - len("Section NOT-IN-LIBRARY object files"))//2) +
                "Section NOT-IN-LIBRARY object files")
            tmp_list = []
            for s in lib_list:
                if s['Name'].find(".o") > 0:
                    tmp_list.append(s)
                    quick_insert_data_line(s)
            sum_data(tmp_list)

        """
        Insert the summary information at the top of this page.
        """
        cursor = self.__cur.execute(
            "select * from Section WHERE name = '{}'".format(self.section_name))
        for row in cursor:
            self.items.insert(0, "Section Name :{}\tTotal Size :{}\tFlash : {}\tRAM : {:<6}\tPad size = {}".
                              format(self.section_name, row[1], total_flash_size, total_ram_size, row[3]))
            break
        self.items.insert(0, self.__line2)
        self.items.insert(0, " " * ((128 - len("Section information"))//2) + "Section information")
        self.items.insert(0, self.__line1)

        """
        Dump detail information of the section.
        """
        index = 4 * ' '
        self.items.append(" " * ((128 - len("Detail information"))//2) + "Detail information")
        self.items.append(self.__line2)
        for s in lib_list:
            self.items.append("{} Code Size = {} RO Data = {} RW Data = {} ZI Data = {}".
                              format(s['Name'], s['Code'], s['RO'], s['RW'], s['ZI']))
            for t in obj_list:
                if t['Lib'] == s['Name']:
                    self.items.append(index + "{} Code Size = {} RO Data = {} RW Data = {} ZI Data = {}".format(
                        t['Name'], t['Code'], t['RO'], t['RW'], t['ZI']))
                    count = 0
                    cursor = self.__cur.execute("select * from Function WHERE section = '{}' and lib_file = '{}' and obj_file = '{}' ORDER BY {} {}".
                                                format(self.section_name,
                                                       s['Name'],
                                                       t['Name'],
                                                       self.sort,
                                                       self.order))
                    for row in cursor:
                        if row and count == 0:
                            self.items.append(index * 2 + "Code size = {}".
                                              format(t['Code']))
                            count = count + 1
                        self.items.append(index * 3 + "{:<6} {} ".
                                          format(row[2], row[0]))

                    def get_certain_data(type_name, s, t):
                        count = 0
                        cursor = self.__cur.execute("select * from Data WHERE section = '{}' and lib_file = '{}' and obj_file = '{}'  and type = '{}' ORDER BY {} {}".
                                                    format(self.section_name,
                                                           s['Name'],
                                                           t['Name'],
                                                           type_name,
                                                           self.sort,
                                                           self.order))
                        for row in cursor:
                            if row and count == 0:
                                self.items.append(index * 2 + "{} Data = {}".
                                                  format(type_name, t[type_name]))
                                count = count + 1
                            self.items.append(index * 3 + "{:<6} {}".
                                              format(row[2], row[0]))

                    get_certain_data('RO', s, t)
                    get_certain_data('RW', s, t)
                    get_certain_data('ZI', s, t)
            self.items.append(self.__line2)
        self.items[-1] = self.__line1

    def draw_section_func(self):
        self.items = ["{:<50}{:<32}{:<10}{:<16}{:<40}{:<40}".
                      format("Name",
                             "Section",
                             "Size",
                             "Address",
                             "Object File",
                             "Library")]
        cursor = self.__cur.execute("select * from Function WHERE section = '{}' ORDER BY {} {}".
                                  format(self.section_name, self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<32}{:<10}{:<16}{:<40}{:<40}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5]))

    def draw_section_data(self):
        self.items = ["{:<50}{:<32}{:<10}{:<16}{:<16}{:<40}{:<40}".
                      format("Name",
                             "Section",
                             "Size",
                             "Address",
                             "Type",
                             "Object File",
                             "Library")]

        cursor = self.__cur.execute("select * from Data WHERE section = '{}' ORDER BY {} {}".
                                  format(self.section_name, self.sort, self.order))
        for row in cursor:
            data_name = row[0]
            if len(data_name) >= 50:
                data_name = data_name[:40] + "-->"
            self.items.append("{:<50}{:<32}{:<10}{:<16}{:<16}{:<40}{:<40}".
                              format(data_name, row[1], row[2], row[3], row[4], row[5], row[6]))

    def __quick_append(self):
        self.items.append(self.__line1)

        self.items.append("{:<50}{:<32}{:<10}{:<16}{:<40}".
                          format("Name",
                                 "Section",
                                 "Size",
                                 "Type",
                                 "Object File"))
        self.items.append(self.__line2)

    def __quick_append_data(self, cursor):
        flag = False
        for row in cursor:
            if not flag:
                self.__quick_append()
            data_name = row[0]
            if len(data_name) >= 50:
                data_name = data_name[:40] + "-->"
            self.items.append("{:<50}{:<32}{:<10}{:<16}{:<40}".
                              format(data_name, row[1], row[2], row[4], row[5]))
            flag = True

    def draw_library_page(self):
        self.items = ["{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                      format("Name",
                             "Flash size",
                             "RAM size",
                             "Code",
                             "RO data",
                             "RW data",
                             "ZI data",
                             "Inc. data",
                             "Debug")]

        cursor = self.__cur.execute(
            "select * from Library ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]))

    def draw_library_detail_page(self):
        flag = False
        """
        Draw title.
        """
        self.items = [self.__line1, "{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                      format("Name",
                             "Flash size",
                             "RAM size",
                             "Code",
                             "RO data",
                             "RW data",
                             "ZI data",
                             "Inc. data"),
                      self.__line2]

        cursor = self.__cur.execute("select * from Library WHERE name = '{}'".
                                  format(self.library_name))
        for row in cursor:
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7]))
            break

        """
        Draw object files.
        """
        self.items.append(self.__line1)
        self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                          format("Name",
                                 "Flash size",
                                 "RAM size",
                                 "Code",
                                 "RO data",
                                 "RW data",
                                 "ZI data",
                                 "Inc. data"))
        self.items.append(self.__line2)

        cursor = self.__cur.execute("select * from Object WHERE lib_file = '{}' ORDER BY {} {}".
                                  format(self.library_name, self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8]))

        """
        Draw functions.
        """
        cursor = self.__cur.execute("select * from Function WHERE lib_file = '{}' ORDER BY {} {}".
                                  format(self.library_name, self.sort, self.order))
        for row in cursor:
            if not flag:
                self.__quick_append()
            self.items.append("{:<50}{:<32}{:<10}{:<16}{:<40}".
                              format(row[0], row[1], row[2], "Code", row[4]))
            flag = True

        """
        Draw RO data.
        """
        cursor = self.__cur.execute("select * from Data WHERE type = 'RO' and lib_file = '{}' ORDER BY {} {}".
                                  format(self.library_name, self.sort, self.order))
        self.__quick_append_data(cursor)

        """
        Draw RW data.
        """
        cursor = self.__cur.execute("select * from Data WHERE type = 'RW' and lib_file = '{}' ORDER BY {} {}".
                                  format(self.library_name, self.sort, self.order))
        self.__quick_append_data(cursor)

        """
        Draw ZI data.
        """
        cursor = self.__cur.execute("select * from Data WHERE type = 'ZI' and lib_file = '{}' ORDER BY {} {}".
                                  format(self.library_name, self.sort, self.order))
        self.__quick_append_data(cursor)
        self.items.append(self.__line1)

    def draw_obj_page(self):
        self.items = ["{:<50}{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                      format("Name",
                             "Library",
                             "Flash size",
                             "RAM size",
                             "Code",
                             "RO data",
                             "RW data",
                             "ZI data",
                             "Inc. data",
                             "Debug")]
        cursor = self.__cur.execute("select * from Object WHERE lib_file = 'no library' ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]))
        cursor = self.__cur.execute(
            "select * from Object WHERE lib_file != 'no library' ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]))

    def draw_obj_detail_page(self):
        flag = False
        self.items = [self.__line1,
                      "{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                      format("Name",
                             "Flash size",
                             "RAM size",
                             "Code",
                             "RO data",
                             "RW data",
                             "ZI data",
                             "Inc. data"),
                      self.__line2]

        cursor = self.__cur.execute("select * from Object WHERE name = '{}'".
                                  format(self.obj_file))
        for row in cursor:
            self.items.append("{:<50}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}{:<12}".
                              format(row[0], row[2], row[3], row[4], row[5], row[6], row[7], row[8]))
            break

        cursor = self.__cur.execute("select * from Function WHERE obj_file = '{}' ORDER BY {} {}".
                                  format(self.obj_file, self.sort, self.order))
        for row in cursor:
            if not flag:
                self.__quick_append()
            self.items.append("{:<50}{:<32}{:<10}{:<16}{:<40}".
                              format(row[0], row[1], row[2], "Code", row[4]))
            flag = True

        cursor = self.__cur.execute("select * from Data WHERE type = 'RO' and obj_file = '{}' ORDER BY {} {}".
                                  format(self.obj_file, self.sort, self.order))
        self.__quick_append_data(cursor)

        cursor = self.__cur.execute("select * from Data WHERE type = 'RW' and obj_file = '{}' ORDER BY {} {}".
                                  format(self.obj_file, self.sort, self.order))
        self.__quick_append_data(cursor)

        cursor = self.__cur.execute("select * from Data WHERE type = 'ZI' and obj_file = '{}' ORDER BY {} {}".
                                  format(self.obj_file, self.sort, self.order))
        self.__quick_append_data(cursor)
        self.items.append(self.__line1)

    def draw_function_page(self, search_func):
        self.items = []
        self.items.append("{:<50}{:<50}{:<10}{:<16}{:<40}{:<40}".
                          format("Name",
                                 "Section",
                                 "Size",
                                 "Address",
                                 "Object File",
                                 "Library"))
        if search_func:
            cursor = self.__cur.execute("select * from Function WHERE name LIKE '%{}%'".
                                      format(search_func))
        else:
            cursor = self.__cur.execute("select * from Function ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            self.items.append("{:<50}{:<50}{:<10}{:<16}{:<40}{:<40}".
                              format(row[0], row[1], row[2], row[3], row[4], row[5]))

    def draw_function_detail_page(self):
        if self.obj_file:
            cursor = self.__cur.execute("select * from Function WHERE name = '{}' and obj_file = '{}'".
                                    format(self.function_name, self.obj_file))
        else:
            cursor = self.__cur.execute("select * from Function WHERE name = '{}'".
                                    format(self.function_name))
        for row in cursor:
            self.items = ["=================================================",
                          "Name\t\t\t: {}".format(row[0]),
                          "Symbol type\t\t: Function",
                          "Section\t\t\t: {}".format(row[1]),
                          "Size\t\t\t: {}".format(row[2]),
                          "Base address\t\t: {}".format(row[3]),
                          "Object file\t\t: {}".format(row[4]),
                          "Library\t\t\t: {}".format(row[5]),
                          "================================================="]

    def draw_data_page(self, search_data):
        self.items = ["{:<50}{:<50}{:<10}{:<16}{:<16}{:<40}{:<40}".
                      format("Name",
                             "Section",
                             "Size",
                             "Address",
                             "Type",
                             "Object File",
                             "Library")]
        if search_data:
            cursor = self.__cur.execute("select * from Data WHERE name LIKE '%{}%'".
                                      format(search_data))
        else:
            cursor = self.__cur.execute("select * from Data ORDER BY {} {}".format(self.sort, self.order))
        for row in cursor:
            data_name = row[0]
            if len(data_name) >= 50:
                data_name = data_name[:40] + "-->"
            self.items.append("{:<50}{:<50}{:<10}{:<16}{:<16}{:<40}{:<40}".
                              format(data_name, row[1], row[2], row[3], row[4], row[5], row[6]))

    def draw_data_detail_page(self):
        if self.obj_file:
            cursor = self.__cur.execute("select * from Data WHERE name = '{}' and obj_file = '{}'".
                                  format(self.data_name, self.obj_file))
        else:
            cursor = self.__cur.execute("select * from Data WHERE name = '{}'".
                                  format(self.data_name))

        for row in cursor:
            self.items = ["=================================================",
                          "Name\t\t\t: {}".format(row[0]),
                          "Symbol type\t\t: {}".format(row[4]),
                          "Section\t\t\t: {}".format(row[1]),
                          "Size\t\t\t: {}".format(row[2]),
                          "Base address\t\t: {}".format(row[3]),
                          "Object file\t\t: {}".format(row[5]),
                          "Library\t\t\t: {}".format(row[6]),
                          "================================================="]

    def run(self):
        """
        Continue running the TUI until get interrupted
        """
        self.open_db()
        self.__init_curses()
        try:
            self.__draw_page()
            self.__input_stream()
        except KeyboardInterrupt:
            pass
        finally:
            self.con.close()
            curses.endwin()