#!/usr/bin/python
# -*- coding: UTF-8 -*-
import re


def auto_parse_include(text, suffix, callback=None):
    # 遍历所有的 '@include' 标签
    xml = suffix == ".xml"
    java = suffix == ".java"

    if xml:
        frgment_new_instance_matches = re.findall(r'<include[\s\S]*?/>', text)
        # print(f"发现include标签：{matches}")
        # 如果存在 '@include' 标签，取出标签中的 layout
        if frgment_new_instance_matches:
            for match in frgment_new_instance_matches:
                layout = re.search(r'layout=\"@layout/([^\"]+)\"', match).group(1)
                if layout and callback:
                    callback(f"{layout}.xml")
                # print(f"解析到include标签：{layout}.xml")

        # 遍历所有的viewStub
        frgment_new_instance_matches = re.findall(r'<ViewStub[\s\S]*?/>', text)
        if frgment_new_instance_matches:
            for match in frgment_new_instance_matches:
                view_stub = re.search(r'layout=\"@layout/([^\"]+)\"', match).group(1)
                print(f"解析到ViewStub：{view_stub}")
                if view_stub and callback:
                    callback(f"{view_stub}.xml")

        # 遍历所有的background
        drawable_background = re.findall(r'android:background=\"@drawable/([^\"]+)\"', text)
        if drawable_background:
            for match in drawable_background:
                print(f"解析到background：{match}")
                if match and callback:
                    callback(f"{match}.xml")

        # 遍历所有的src
        drawable_src = re.findall(r'android:src=\"@drawable/([^\"]+)\"', text)
        if drawable_src:
            for match in drawable_src:
                print(f"解析到src：{match}")
                if match and callback:
                    callback(f"{match}.xml")

    if java:
        # 遍历所有的 'R.layout.xxxxxxx' 代码
        frgment_new_instance_matches = re.findall(r'R\.layout\.\w*\b', text)
        if frgment_new_instance_matches:
            for match in frgment_new_instance_matches:
                layout = re.search(r'R\.layout\.(\w*)\b', match).group(1)
                if layout and callback:
                    callback(f"{layout}.xml")

        # 遍历所有的viewBinding
        # inflate 或者 bind匹配
        bind_inflate_matches = re.findall(r'(\w+Binding)\.(?:bind|inflate)+', text)
        if bind_inflate_matches:
            for match in bind_inflate_matches:
                v1 = re.search(r'(\w+)Binding', match).group(1)
                print(f"解析到viewBinding：{v1} bind或者inflate")
                # 将v2的驼峰改为下划线命名,首字母小写
                v1 = re.sub(r'(?<!^)([A-Z])', r'_\1', v1).lower()
                if v1 and callback:
                    callback(f"{v1}.xml")

        # 泛型匹配
        generics_matches = re.findall(r'<(\w+)Binding+,\s*(\w+)?Binding?>', text)
        if generics_matches:
            for match in generics_matches:
                for v2 in match:
                    if v2:
                        print(f"解析到viewBinding：{v2} 泛型匹配")
                        # 将v2的驼峰改为下划线命名,首字母小写
                        v2 = re.sub(r'(?<!^)([A-Z])', r'_\1', v2).lower()
                        if v2 and callback:
                            callback(f"{v2}.xml")

        # 遍历所有的fragment
        # 取出 public class StrategyFragment extends的类名
        class_name = re.findall(r'\s+class\s+(\w+Fragment\d?)\s+', text)
        class_name = class_name[0] if class_name else None

        # 匹配*Fragment.newInstance
        frgment_new_instance_matches = re.findall(r'\b(\w+Fragment\d?)\.newI', text)
        if frgment_new_instance_matches:
            for fragment in frgment_new_instance_matches:
                print(f"解析到fragment newInstance：{fragment}")
                if fragment and callback:
                    callback(f'{fragment}.java')

        # 匹配new *Fragment()
        new_fragment_matches = re.findall(r'\bnew\s+(\w+Fragment\d?)\(', text)
        if new_fragment_matches:
            for new_fragment in new_fragment_matches:
                # 不匹配new 自己的class
                no_new_self = not (new_fragment == class_name)
                if new_fragment and no_new_self and callback:
                    print(f"解析到fragment new：{new_fragment}")
                    callback(f'{new_fragment}.java')

        # 遍历所有的adapter
        # 取出 public class StrategyFragment extends的类名
        class_name = re.findall(r'\s+class\s+(\w+Adapter\d?)\s+', text)
        class_name = class_name[0] if class_name else None

        # 匹配*Adapter.newInstance
        adapter_new_instance_matches = re.findall(r'\b(\w+Adapter\d?)\.newI', text)
        if adapter_new_instance_matches:
            for adapter in adapter_new_instance_matches:
                print(f"解析到adapter newInstance：{adapter}")
                if adapter and callback:
                    callback(f'{adapter}.java')

        # 匹配new *Adapter()
        new_adapter_matches = re.findall(r'\bnew\s+(\w+Adapter\d?)\(', text)
        if new_adapter_matches:
            for new_adapter in new_adapter_matches:
                # 不匹配new 自己的class
                no_new_self = not (new_adapter == class_name)
                if new_adapter and no_new_self and callback:
                    print(f"解析到adapter new：{new_adapter}")
                    callback(f'{new_adapter}.java')

        # 遍历所有的delegate
        # 取出 public class StrategyFragment extends的类名
        class_name = re.findall(r'\s+class\s+(\w+Delegate\d?)\s+', text)
        class_name = class_name[0] if class_name else None

        # 匹配*Delegate.newInstance
        delegate_new_instance_matches = re.findall(r'\b(\w+Delegate\d?)\.newI', text)
        if delegate_new_instance_matches:
            for delegate in delegate_new_instance_matches:
                print(f"解析到delegate newInstance：{delegate}")
                if delegate and callback:
                    callback(f'{delegate}.java')

        # 匹配new *Delegate()
        new_delegate_matches = re.findall(r'\bnew\s+(\w+Delegate\d?)\(', text)
        if new_delegate_matches:
            for new_delegate in new_delegate_matches:
                # 不匹配new 自己的class
                no_new_self = not (new_delegate == class_name)
                if new_delegate and no_new_self and callback:
                    print(f"解析到delegate new：{new_delegate}")
                    callback(f'{new_delegate}.java')