#!/usr/bin/env python3
"""
LVGL Header Preprocessor

Extracts function signatures and enums from LVGL header files.
Generates mapping files for Berry scripting integration.
"""

import re
import sys
import glob
import argparse
from pathlib import Path
from typing import List, Set, Tuple, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
logger = logging.getLogger(__name__)


class LVGLPreprocessor:
    """Main preprocessor class for LVGL headers."""
    
    def __init__(self, lv_src_prefix: str = "../../lvgl/src/"):
        self.lv_src_prefix = Path(lv_src_prefix)
        self.headers_exclude_suffix = {
            "_private.h",
            "lv_lottie.h", 
            "lv_obj_property.h",
            "lv_obj_property_names.h",
            "lv_style_properties.h",
            "lv_3dtexture.h",
        }
        
        # Function exclusion patterns
        self.function_exclude_patterns = [
            r"^_",                        # skip if function name starts with '_'
            r"^lv_debug",                 # all debug functions
            r"^lv_init", r"^lv_deinit",
            r"^lv_templ_",
            r"^lv_imagebutton_get_src_",  # LV_IMGBTN_TILED == 0
            r"^lv_imagebitton_set_src_tiled",  # !LV_IMGBTN_TILED
            r"^lv_refr_get_fps_",         # no LV_USE_PERF_MONITOR
            r"^lv_image_cache_",
            r"^lv_image_decoder_",
            r"^lv_image_cf_",
            r"^lv_image_buf_",
            r"^lv_indev_scroll_",
            r"^lv_pow",
            r"^lv_keyboard_def_event_cb", # need to fix conditional include
            r"^lv_refr_reset_fps_counter",
            r"^lv_refr_get_fps_avg",
            r"^lv_anim_path_",            # callbacks for animation are moved to constants
            r"^lv_obj_set_property",      # LV_USE_OBJ_PROPERTY 0
            r"^lv_obj_set_properties",
            r"^lv_obj_get_property",
            r"^lv_win_",
            r"^lv_obj.*name",             # we don't enable #if LV_USE_OBJ_NAME
        ]
        
        # Enum exclusion patterns
        self.enum_exclude_prefixes = {
            "_", "LV_BIDI_DIR_", "LV_FONT_", "LV_SIGNAL_", "LV_TEMPL_", 
            "LV_TASK_PRIO_", "LV_THEME_", "LV_LRU_", "LV_VECTOR_",
            "LV_KEYBOARD_MODE_TEXT_ARABIC", "LV_DRAW_TASK_TYPE_3D", 
            "LV_DRAW_TASK_TYPE_VECTOR",
        }

    def comment_remover(self, text: str) -> str:
        """Remove C/C++ style comments from source code."""
        def replacer(match):
            s = match.group(0)
            return " " if s.startswith('/') else s
        
        pattern = re.compile(
            r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
            re.DOTALL | re.MULTILINE
        )
        return re.sub(pattern, replacer, text)

    def list_files(self, prefix: Path, glob_patterns: List[str]) -> List[Path]:
        """Compute a sorted list of files from a prefix and glob patterns."""
        files = []
        for pattern in glob_patterns:
            files.extend(Path(prefix).glob(pattern))
        return sorted(files)

    def clean_source(self, raw: str) -> str:
        """Clean source code by removing comments, preprocessor directives, etc."""
        raw = self.comment_remover(raw)
        
        # Normalize line endings
        raw = re.sub(r'\r\n', '\n', raw)
        raw = re.sub(r'\r', '\n', raw)
        
        # Handle line continuations
        raw = re.sub(r'\\\n', ' ', raw)
        
        # Remove preprocessor directives
        raw = re.sub(r'\n[ \t]*#[^\n]*(?=\n)', '', raw)
        raw = re.sub(r'^[ \t]*#[^\n]*\n', '', raw)
        raw = re.sub(r'\n[ \t]*#[^\n]*$', '', raw)

        # Remove extern "C" blocks
        raw = re.sub(r'extern\s+"C"\s+{(.*)}', r'\1', raw, flags=re.DOTALL)

        # Remove empty lines
        raw = re.sub(r'\n[ \t]*(?=\n)', '', raw)
        raw = re.sub(r'^[ \t]*\n', '', raw)
        raw = re.sub(r'\n[ \t]*$', '', raw)
        
        return raw

    def extract_functions(self, source: str) -> List[str]:
        """Extract function signatures from cleaned source code."""
        # Remove content within braces
        while True:
            source, repl_count = re.subn(r'\{[^{]*?\}', ';', source, flags=re.DOTALL)
            if repl_count == 0:
                break

        # Find function signatures
        pattern = r'(^|;|})\s*([^;{}]+\(.*?\))\s*(?=(;|{))'
        matches = re.findall(pattern, source, flags=re.DOTALL)
        
        functions = []
        for match in matches:
            func_def = match[1]
            # Clean up whitespace
            func_def = re.sub(r'[ \t\r\n]+', ' ', func_def)
            
            # Remove LVGL-specific attributes
            func_def = re.sub(r'LV_ATTRIBUTE_FAST_MEM ', '', func_def)
            func_def = re.sub(r'LV_ATTRIBUTE_TIMER_HANDLER ', '', func_def)
            func_def = re.sub(r'extern ', '', func_def)
            
            # Skip excluded function types
            if any(func_def.startswith(prefix) for prefix in ["typedef", "_LV_", "LV_"]):
                continue
                
            # Extract function name
            name_match = re.search(r'\s(\w+)\([^\(]*$', func_def)
            if not name_match:
                continue
                
            func_name = name_match.group(1)
            
            # Check exclusion patterns
            if any(re.search(pattern, func_name) for pattern in self.function_exclude_patterns):
                continue
                
            functions.append(func_def)
            
        return functions

    def extract_enums(self, source: str) -> Set[str]:
        """Extract enum values from cleaned source code."""
        enum_values = set()
        
        # Find enum definitions
        enum_matches = re.findall(r'enum\s+\w*\s*{(.*?)}', source, flags=re.DOTALL)
        
        for enum_content in enum_matches:
            # Skip LV_PROPERTY_ID enums (disabled feature)
            if 'LV_PROPERTY_ID' in enum_content:
                continue
                
            # Remove macro-defined enums
            enum_content = re.sub(r'\S+\((.*?),.*?\),', r'\1,', enum_content)
            
            # Split by commas and clean up
            for item in enum_content.split(','):
                item = re.sub(r'[ \t\n]', '', item)  # Remove whitespace
                item = re.sub(r'=.*$', '', item)     # Remove assignment
                
                if not item:  # Skip empty items
                    continue
                    
                # Check exclusion patterns
                if any(item.startswith(prefix) for prefix in self.enum_exclude_prefixes):
                    continue
                    
                enum_values.add(item)
        
        # Extract LV_EXPORT_CONST_INT constants
        const_ints = re.findall(r'LV_EXPORT_CONST_INT\((\w+)\)', source, flags=re.DOTALL)
        enum_values.update(const_ints)
        
        return enum_values

    def get_function_headers(self) -> List[Path]:
        """Get list of header files for function extraction."""
        patterns = [
            "lv_api*.h",
            "widgets/*/*.h",
            "libs/qrcode/lv_qrcode.h",
            "core/*.h",
            "indev/lv_indev.h",
            "layouts/*/*.h",
            "themes/lv_theme.h",
            "draw/lv_draw_arc.h",
            "draw/lv_draw_label.h", 
            "draw/lv_draw_line.h",
            "draw/lv_draw_mask.h",
            "draw/lv_draw_rect.h",
            "draw/lv_draw_triangle.h",
            "draw/lv_draw.h",
            "display/*.h",
            "misc/lv_anim.h",
            "misc/lv_area.h",
            "misc/lv_color.h",
            "misc/lv_color_op.h",
            "misc/lv_palette.h",
            "misc/lv_event.h",
            "misc/lv_style_gen.h",
            "misc/lv_style.h",
            "misc/lv_timer.h",
            "misc/lv_text.h",
            "font/lv_font.h",
            "../lvgl.h",
        ]
        
        headers = self.list_files(self.lv_src_prefix, patterns)
        
        # Add additional headers
        additional_paths = [
            Path("../../LVGL_assets/src/lv_theme_haspmota.h"),
            Path("../src/lv_berry.h"),
            Path("../src/lv_colorwheel.h"),
        ]
        
        for path in additional_paths:
            if path.exists():
                headers.append(path)
        
        # Filter out excluded files
        return [h for h in headers if not any(str(h).endswith(suffix) for suffix in self.headers_exclude_suffix)]

    def get_enum_headers(self) -> List[Path]:
        """Get list of header files for enum extraction."""
        patterns = [
            "core/*.h",
            "draw/*.h", 
            "hal/*.h",
            "misc/*.h",
            "widgets/*/*.h",
            "display/lv_display.h",
            "layouts/**/*.h",
        ]
        
        headers = self.list_files(self.lv_src_prefix, patterns)
        return [h for h in headers if not any(str(h).endswith(suffix) for suffix in self.headers_exclude_suffix)]

    def generate_functions_header(self, output_path: Path):
        """Generate the functions header file."""
        logger.info(f"Generating functions header: {output_path}")
        
        headers = self.get_function_headers()
        
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write("""
// Automatically generated from LVGL source with `python3 preprocessor.py`
// Extract function signatures from LVGL APIs in headers

// Custom Tasmota functions
lv_ts_calibration_t * lv_get_ts_calibration(void);

// ======================================================================
// LV top level functions
// ======================================================================

// resolution
lv_coord_t lv_get_hor_res(void);
lv_coord_t lv_get_ver_res(void);

// ======================================================================
// Generated from headers
// ======================================================================

""")
            
            for header_path in headers:
                try:
                    with open(header_path, encoding='utf-8-sig') as header_file:
                        f.write(f"// {header_path}\n")
                        
                        raw_content = self.clean_source(header_file.read())
                        functions = self.extract_functions(raw_content)
                        
                        for func in functions:
                            f.write(f"{func}\n")
                        f.write("\n")
                        
                except Exception as e:
                    logger.error(f"Error processing {header_path}: {e}")

    def generate_enums_header(self, output_path: Path):
        """Generate the enums header file."""
        logger.info(f"Generating enums header: {output_path}")
        
        headers = self.get_enum_headers()
        
        with open(output_path, 'w', encoding='utf-8') as f:
            # Write the static content first
            f.write(self._get_static_enum_content())
            
            # Process headers for dynamic enums
            for header_path in headers:
                try:
                    with open(header_path, encoding='utf-8-sig') as header_file:
                        f.write(f"// File: {header_path}\n")
                        
                        raw_content = self.clean_source(header_file.read())
                        enum_values = self.extract_enums(raw_content)
                        
                        for enum_value in sorted(enum_values):
                            f.write(f"{enum_value}\n")
                        f.write("\n")
                        
                except Exception as e:
                    logger.error(f"Error processing {header_path}: {e}")

    def _get_static_enum_content(self) -> str:
        """Get the static content for enum header."""
        return """// ======================================================================
// Functions
// ======================================================================

load_font=@lv0_load_font

// lv_anim_path_functions
anim_path_bounce=&lv_anim_path_bounce
anim_path_ease_in=&lv_anim_path_ease_in
anim_path_ease_in_out=&lv_anim_path_ease_in_out
anim_path_ease_out=&lv_anim_path_ease_out
anim_path_linear=&lv_anim_path_linear
anim_path_overshoot=&lv_anim_path_overshoot
anim_path_step=&lv_anim_path_step
LV_LAYOUT_GRID=>be_LV_LAYOUT_GRID
LV_LAYOUT_FLEX=>be_LV_LAYOUT_FLEX

// ======================================================================
// Colors
// ======================================================================
// LV Colors - we store in 24 bits format and will convert at runtime
// This is specific treatment because we keep colors in 24 bits format
COLOR_WHITE=0xFFFFFF
COLOR_SILVER=0xC0C0C0
COLOR_GRAY=0x808080
COLOR_GREY=0x808080         // OpenHASP
COLOR_BLACK=0x000000
COLOR_RED=0xFF0000
COLOR_MAROON=0x800000
COLOR_YELLOW=0xFFFF00
COLOR_OLIVE=0x808000
COLOR_LIME=0x00FF00
COLOR_GREEN=0x008000
COLOR_CYAN=0x00FFFF
COLOR_AQUA=0x00FFFF
COLOR_TEAL=0x008080
COLOR_BLUE=0x0000FF
COLOR_NAVY=0x000080
COLOR_MAGENTA=0xFF00FF
COLOR_FUCHSIA=0xFF00FF      // OpenHASP
COLOR_ORANGE=0xFFA500       // OpenHASP
COLOR_PURPLE=0x800080
// Below are OpenHASP additions
COLOR_PERU=0xCD853F
COLOR_SIENNA=0xA0522D
COLOR_BROWN=0xA52A2A
COLOR_SNOW=0xFFFAFA
COLOR_IVORY=0xFFFFF0
COLOR_LINEN=0xFAF0E6
COLOR_BEIGE=0xF5F5DC
COLOR_AZURE=0xF0FFFF
COLOR_PINK=0xFFC0CB
COLOR_PLUM=0xDDA0DD
COLOR_ORCHID=0xDA70D6
COLOR_VIOLET=0xEE82EE
COLOR_INDIGO=0x4B0082
COLOR_BLUSH=0xB00000
COLOR_TOMATO=0xFF6347
COLOR_SALMON=0xFA8072
COLOR_CORAL=0xFF7F50
COLOR_GOLD=0xFFD700
COLOR_KHAKI=0xF0E68C
COLOR_BISQUE=0xFFE4C4
COLOR_WHEAT=0xF5DEB3
COLOR_TAN=0xD2B48C

// Freetype
FT_FONT_STYLE_NORMAL=FT_FONT_STYLE_NORMAL
FT_FONT_STYLE_ITALIC=FT_FONT_STYLE_ITALIC
FT_FONT_STYLE_BOLD=FT_FONT_STYLE_BOLD

// following are #define, not enum
LV_GRID_FR=LV_GRID_FR(0)

// ======================================================================
// Symbols
// ======================================================================

SYMBOL_AUDIO="\\xef\\x80\\x81"
SYMBOL_VIDEO="\\xef\\x80\\x88"
SYMBOL_LIST="\\xef\\x80\\x8b"
SYMBOL_OK="\\xef\\x80\\x8c"
SYMBOL_CLOSE="\\xef\\x80\\x8d"
SYMBOL_POWER="\\xef\\x80\\x91"
SYMBOL_SETTINGS="\\xef\\x80\\x93"
SYMBOL_HOME="\\xef\\x80\\x95"
SYMBOL_DOWNLOAD="\\xef\\x80\\x99"
SYMBOL_DRIVE="\\xef\\x80\\x9c"
SYMBOL_REFRESH="\\xef\\x80\\xa1"
SYMBOL_MUTE="\\xef\\x80\\xa6"
SYMBOL_VOLUME_MID="\\xef\\x80\\xa7"
SYMBOL_VOLUME_MAX="\\xef\\x80\\xa8"
SYMBOL_IMAGE="\\xef\\x80\\xbe"
SYMBOL_EDIT="\\xef\\x8C\\x84"
SYMBOL_PREV="\\xef\\x81\\x88"
SYMBOL_PLAY="\\xef\\x81\\x8b"
SYMBOL_PAUSE="\\xef\\x81\\x8c"
SYMBOL_STOP="\\xef\\x81\\x8d"
SYMBOL_NEXT="\\xef\\x81\\x91"
SYMBOL_EJECT="\\xef\\x81\\x92"
SYMBOL_LEFT="\\xef\\x81\\x93"
SYMBOL_RIGHT="\\xef\\x81\\x94"
SYMBOL_PLUS="\\xef\\x81\\xa7"
SYMBOL_MINUS="\\xef\\x81\\xa8"
SYMBOL_EYE_OPEN="\\xef\\x81\\xae"
SYMBOL_EYE_CLOSE="\\xef\\x81\\xb0"
SYMBOL_WARNING="\\xef\\x81\\xb1"
SYMBOL_SHUFFLE="\\xef\\x81\\xb4"
SYMBOL_UP="\\xef\\x81\\xb7"
SYMBOL_DOWN="\\xef\\x81\\xb8"
SYMBOL_LOOP="\\xef\\x81\\xb9"
SYMBOL_DIRECTORY="\\xef\\x81\\xbb"
SYMBOL_UPLOAD="\\xef\\x82\\x93"
SYMBOL_CALL="\\xef\\x82\\x95"
SYMBOL_CUT="\\xef\\x83\\x84"
SYMBOL_COPY="\\xef\\x83\\x85"
SYMBOL_SAVE="\\xef\\x83\\x87"
SYMBOL_CHARGE="\\xef\\x83\\xa7"
SYMBOL_PASTE="\\xef\\x83\\xAA"
SYMBOL_BELL="\\xef\\x83\\xb3"
SYMBOL_KEYBOARD="\\xef\\x84\\x9c"
SYMBOL_GPS="\\xef\\x84\\xa4"
SYMBOL_FILE="\\xef\\x85\\x9b"
SYMBOL_WIFI="\\xef\\x87\\xab"
SYMBOL_BATTERY_FULL="\\xef\\x89\\x80"
SYMBOL_BATTERY_3="\\xef\\x89\\x81"
SYMBOL_BATTERY_2="\\xef\\x89\\x82"
SYMBOL_BATTERY_1="\\xef\\x89\\x83"
SYMBOL_BATTERY_EMPTY="\\xef\\x89\\x84"
SYMBOL_USB="\\xef\\x8a\\x87"
SYMBOL_BLUETOOTH="\\xef\\x8a\\x93"
SYMBOL_TRASH="\\xef\\x8B\\xAD"
SYMBOL_BACKSPACE="\\xef\\x95\\x9A"
SYMBOL_SD_CARD="\\xef\\x9F\\x82"
SYMBOL_NEW_LINE="\\xef\\xA2\\xA2"

SYMBOL_DUMMY="\\xEF\\xA3\\xBF"

SYMBOL_BULLET="\\xE2\\x80\\xA2"
      
// LVGL 8 to 9 compatibility
      
LV_DISP_ROTATION_0=LV_DISPLAY_ROTATION_0
LV_DISP_ROTATION_90=LV_DISPLAY_ROTATION_90
LV_DISP_ROTATION_180=LV_DISPLAY_ROTATION_180
LV_DISP_ROTATION_270=LV_DISPLAY_ROTATION_270

LV_DISP_RENDER_MODE_PARTIAL=LV_DISPLAY_RENDER_MODE_PARTIAL
LV_DISP_RENDER_MODE_DIRECT=LV_DISPLAY_RENDER_MODE_DIRECT
LV_DISP_RENDER_MODE_FULL=LV_DISPLAY_RENDER_MODE_FULL

LV_BTNMATRIX_BTN_NONE=LV_BUTTONMATRIX_BUTTON_NONE

LV_BTNMATRIX_CTRL_HIDDEN=LV_BUTTONMATRIX_CTRL_HIDDEN
LV_BTNMATRIX_CTRL_NO_REPEAT=LV_BUTTONMATRIX_CTRL_NO_REPEAT
LV_BTNMATRIX_CTRL_DISABLED=LV_BUTTONMATRIX_CTRL_DISABLED
LV_BTNMATRIX_CTRL_CHECKABLE=LV_BUTTONMATRIX_CTRL_CHECKABLE
LV_BTNMATRIX_CTRL_CHECKED=LV_BUTTONMATRIX_CTRL_CHECKED
LV_BTNMATRIX_CTRL_CLICK_TRIG=LV_BUTTONMATRIX_CTRL_CLICK_TRIG
LV_BTNMATRIX_CTRL_POPOVER=LV_BUTTONMATRIX_CTRL_POPOVER
LV_BTNMATRIX_CTRL_CUSTOM_1=LV_BUTTONMATRIX_CTRL_CUSTOM_1
LV_BTNMATRIX_CTRL_CUSTOM_2=LV_BUTTONMATRIX_CTRL_CUSTOM_2

LV_RES_OK=LV_RESULT_OK
LV_RES_INV=LV_RESULT_INVALID

LV_INDEV_STATE_PR=LV_INDEV_STATE_PRESSED
LV_INDEV_STATE_REL=LV_INDEV_STATE_RELEASED

LV_STYLE_ANIM_TIME=LV_STYLE_ANIM_DURATION
LV_STYLE_IMG_OPA=LV_STYLE_IMAGE_OPA
LV_STYLE_IMG_RECOLOR=LV_STYLE_IMAGE_RECOLOR
LV_STYLE_IMG_RECOLOR_OPA=LV_STYLE_IMAGE_RECOLOR_OPA
LV_STYLE_SHADOW_OFS_X=LV_STYLE_SHADOW_OFFSET_X
LV_STYLE_SHADOW_OFS_Y=LV_STYLE_SHADOW_OFFSET_Y
LV_STYLE_TRANSFORM_ANGLE=LV_STYLE_TRANSFORM_ROTATION

LV_ZOOM_NONE=LV_SCALE_NONE

// LVGL 9.3
LV_LABEL_LONG_WRAP=LV_LABEL_LONG_MODE_WRAP
LV_LABEL_LONG_DOT=LV_LABEL_LONG_MODE_DOTS
LV_LABEL_LONG_SCROLL=LV_LABEL_LONG_MODE_SCROLL
LV_LABEL_LONG_SCROLL_CIRCULAR=LV_LABEL_LONG_MODE_SCROLL_CIRCULAR
LV_LABEL_LONG_CLIP=LV_LABEL_LONG_MODE_CLIP

// ======================================================================
// Generated from headers
// ======================================================================
"""

    def run(self, functions_output: str = "../mapping/lv_funcs.h", 
            enums_output: str = "../mapping/lv_enum.h"):
        """Run the complete preprocessing pipeline."""
        functions_path = Path(functions_output)
        enums_path = Path(enums_output)
        
        # Create output directories if they don't exist
        functions_path.parent.mkdir(parents=True, exist_ok=True)
        enums_path.parent.mkdir(parents=True, exist_ok=True)
        
        # Generate both files
        self.generate_functions_header(functions_path)
        self.generate_enums_header(enums_path)
        
        logger.info("Preprocessing complete!")


def main():
    """Main entry point with command line argument parsing."""
    parser = argparse.ArgumentParser(description="LVGL Header Preprocessor")
    parser.add_argument("--lv-src", default="../../lvgl/src/", 
                       help="Path to LVGL source directory")
    parser.add_argument("--functions-output", default="../mapping/lv_funcs.h",
                       help="Output path for functions header")
    parser.add_argument("--enums-output", default="../mapping/lv_enum.h", 
                       help="Output path for enums header")
    parser.add_argument("--verbose", "-v", action="store_true",
                       help="Enable verbose logging")
    
    args = parser.parse_args()
    
    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)
    
    try:
        preprocessor = LVGLPreprocessor(args.lv_src)
        preprocessor.run(args.functions_output, args.enums_output)
    except Exception as e:
        logger.error(f"Preprocessing failed: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()
