#!/usr/bin/env python3

import argparse
import re
import yaml
import json
import inspect
from pathlib import Path

from encodings import undefined

gr = re.compile(r'.*(\.|->)add_group\(\s*(.*)')
desc = re.compile(r'.*..::descrs\( *("[^"]+")(.*)')
alternative_name = re.compile(r'([^,]*),')
metric = re.compile(r'.*..::make_(absolute|counter|current|derive|gauge|histogram|queue|summary|total|total_operations|queue_length|total_bytes|current_bytes)\((.*)')
string_content = re.compile(r'\s*"([^"]+)"\s*,.*')
string_match = re.compile(r'"([^"]+)"')
sstring_match = re.compile(r'\s*sstring\(\s*("[^"]+")\s*\)\s*')
metrics_directive = re.compile(r'.*@metrics\s*([^=]+)\s*=\s*(\[[^\]]*\]).*')
format_match = re.compile(r'\s*(?:seastar::)?format\(\s*"([^"]+)"\s*,\s*(.*)\s*')

def handle_error(message, strict=True, verbose_mode=False):
    if strict:
        print(f"[ERROR] {message}")
        exit(1)
    elif verbose_mode:
        print(f"[WARNING] {message}")

def verbose(verb, *arg):
    if verb:
        print(*arg)

def get_end_part(str):
    parenthes_count = 0
    for idx, c in enumerate(str):
        if c == ',' and parenthes_count == 0:
            return str[:idx]
        if c ==')':
            parenthes_count -= 1
        if c =='(':
            parenthes_count += 1
    return None

def find_end_parenthes(str, pc):
    for idx, c in enumerate(str):
        if c ==')':
            pc -= 1
        if c =='(':
            pc += 1
        if pc == 0:
            return str[:idx]
    return str

def split_paterns(str):
    res = []
    pos = 0
    b = 0
    cur_str = ""
    while pos < len(str):
        if str[pos] == '+':
            res.append(cur_str)
            cur_str = ""
        elif str[pos] == '(':
            s = find_end_parenthes(str[pos+1:], 1)
            cur_str += "(" +s +")"
            pos += len(s) + 1
        else:
            cur_str += str[pos]
        pos += 1
    if cur_str:
        res.append(cur_str)
    return res

def validate_parameter(txt, param_mapping, err="", strict=True, verbose_mode=False):
    if isinstance(txt, str):
        txt = [txt]
    for t in txt:
        if t not in param_mapping:
            handle_error(f"Could not resolve param {err} {t}", strict, verbose_mode)
            return None
        if not param_mapping[t]:
            handle_error(f"Could not resolve param is empty {err} {txt}", strict, verbose_mode)
            return None
    return txt
def sort_by_index(arr,ind):
    return [arr[i] for i in ind]

def make_name_list(names, err, param_mapping, verb=None, strict=True):
    param = []
    format_string = ""
    for txt in names:
        if isinstance(txt, dict):
            format_string += txt['str']
            param = param + ([txt['param']] if isinstance(txt['param'], str) else txt['param'])
        else:
            if txt[0] == '"':
                format_string += txt[1:-1]
            else:
                param = param + validate_parameter(txt, param_mapping, "(make_name_list:"+ str(inspect.getframeinfo(inspect.currentframe()).lineno) +")"+err, strict, verb)
                format_string += "{}"
                if not param:
                    handle_error(f"make_name_list:{inspect.getframeinfo(inspect.currentframe()).lineno} {names}", strict, verb)
                    return None
    if not param:
        return [format_string]
    order_params = list(enumerate(param))
    sorted_indexed_array = sorted(order_params, key=lambda x: x[1])
    indexed_array = [index for index, value in sorted_indexed_array]
    verbose(verb, "make_name_list", param)
    param.sort()
    param_keys = ';'.join(param)
    if param_keys not in param_mapping:
        handle_error(f"Parameter not found: {param_keys} {err}", strict)
        return None
    for p in param_mapping[param_keys]:
        if not p:
            handle_error(f"empty (make_name_list:{inspect.getframeinfo(inspect.currentframe()).lineno}){err} {param}", strict)
            return None
    verbose(verb, "make_name_list", [format_string.format(p) for p in param_mapping[param[0]]] if len(param) == 1 else [format_string.format(*sort_by_index(p,indexed_array)) for p in param_mapping[param_keys]])
    return [format_string.format(p) for p in param_mapping[param[0]]] if len(param) == 1 else [format_string.format(*sort_by_index(p,indexed_array)) for p in param_mapping[param_keys]]

def get_decription(str):
    b = str.find('::description(') + len('::description(')
    p = b
    parenthes_count = 1
    while p < len(str):
        if str[p] == '"':
            p = str.find('"',p+1)
            if p <0:
                break
        if str[p] == '(':
            parenthes_count += 1
        if str[p] == ')':
            parenthes_count -= 1
        if parenthes_count == 0:
            return str[b:p]
        p = p + 1
    return None

def merge_strings(str, str2):
    if str and str.rstrip()[-1] == '"':
        if str2 and str2.lstrip()[0] == '"':
            return str.rstrip()[:-1] + str2.lstrip()[1:]
    return str.rstrip() + ' ' + str2.lstrip()

def clear_string(str):
    m = sstring_match.match(str)
    if m:
        return m.group(1)
    m = format_match.match(str)
    if m:
        params =  [p.strip() for p in find_end_parenthes(m.group(2), 1).split(',')]
        return {'str': m.group(1), 'param': params[0] if len(params) == 1 else params}
    return str.strip()

def get_metrics_information(config_file):
    with open(config_file, 'r') as file:
        return yaml.safe_load(file)

def get_metrics_from_file(file_name, prefix, metrics_information, verb=None, strict=True):
    current_group = ""
    # Normalize path for cross-platform compatibility
    # Convert absolute paths to relative and backslashes to forward slashes
    clean_name = file_name
    if file_name.startswith('./'):
        clean_name = file_name[2:]
    else:
        # Handle absolute paths (Windows: C:\..., Unix: /...)
        file_path = Path(file_name)
        if file_path.is_absolute():
            try:
                # Try to make it relative to current directory
                clean_name = str(file_path.relative_to(Path.cwd()))
            except ValueError:
                # If not relative to cwd, just use the name as-is
                clean_name = file_name
    # Normalize backslashes to forward slashes for config file compatibility
    clean_name = clean_name.replace('\\', '/')
    param_mapping = {}
    groups = {}
    if clean_name in metrics_information:
        if (isinstance(metrics_information[clean_name], str) and metrics_information[clean_name] == "skip") or "skip" in metrics_information[clean_name]:
            return {}
    param_mapping =  metrics_information[clean_name]["params"] if clean_name in metrics_information and "params" in metrics_information[clean_name] else {}
    groups = metrics_information[clean_name]["groups"] if clean_name in metrics_information and "groups" in metrics_information[clean_name] else {}

    metrics = {}
    names = undefined
    typ = undefined
    line_number = 0;
    current_metric = ""
    parenthes_count = 0
    serching_group = False
    with open(file_name) as file:
        for line in file:
            if str(line_number) in groups:
                current_group = groups[str(line_number)]
                verbose(verb, "found group from config ", groups[str(line_number)])
            if serching_group:
                m = string_content.match(line)
                if not m:
                    line_number += 1
                    continue
                current_group = m.group(1)
                serching_group = False
                verbose(verb, "group found on new line", current_group)
            m = metric.match(line)
            # Check if add_group and metric are on the same line
            if m and not current_group:
                gr_match = gr.match(line)
                if gr_match:
                    # Extract group from add_group on the same line
                    current_group = gr_match.group(2)
                    m_str = string_content.match(current_group)
                    if m_str:
                        current_group = m_str.group(1)
                    else:
                        m_alt = alternative_name.match(current_group)
                        if m_alt:
                            current_group = param_mapping[m_alt.group(1)] if m_alt.group(1) in param_mapping else m_alt.group(1)
                    verbose(verb, "group found on same line as metric", current_group)
                else:
                    handle_error(f"new name found with no group {file_name} {line_number} {line}", strict)
                    continue
            if current_metric or m:
                # Only error if add_group appears after we've started processing a metric
                if current_metric and gr.match(line):
                    handle_error(f"add group found unexpectedly {file_name} {line_number} {line}", strict)
                    continue
                if current_metric and m:
                    handle_error(f"new metrics was found while parsing the previous one {file_name} {line_number} {line}", strict)
                    continue
                ln = line.replace('\\"','#').rstrip()
                current_metric = merge_strings(current_metric, ln)
                no_string = re.sub(string_match, '', ln)
                parenthes_count += no_string.count('(')
                parenthes_count -= no_string.count(')')
                if parenthes_count <= 0:
                    verbose(verb, current_metric, file_name, line_number)
                    m = metric.match(current_metric)
                    typ = m.group(1) # type is taken from the make_metrics part
                    prt = m.group(2)
                    m = string_content.match(m.group(2))
                    if not m:
                        multi_part_name = get_end_part(prt)
                        #m = alternative_name.match(prt)
                        verbose(verb, "multi part name ", multi_part_name)
                        if multi_part_name:
                            names = [clear_string(s) for s in multi_part_name.split('+')]
                        else:
                            handle_error(f"names not found {file_name} {line_number} {line} {current_metric}", strict)
                            continue
                    else:
                        names = ['"'  + m.group(1) + '"']
                    desc_str = get_decription(current_metric)
                    if desc_str:
                        m = string_match.match(desc_str)
                        if m:
                            descrs = [desc_str]
                        else:
                            descrs = [clear_string(s) for s in split_paterns(desc_str)]
                    else:
                        handle_error(f"description not found {file_name} {line_number} {line} {current_metric}", strict)
                        continue
                    name_list = make_name_list(names, file_name+" "+str(line_number), param_mapping, verb, strict)
                    if not name_list:
                        handle_error(f"no name list {current_metric}", strict)
                        continue
                    description_list = make_name_list(descrs, file_name+" "+str(line_number), param_mapping, verb, strict)
                    current_groups = current_group if isinstance(current_group, list) else [current_group]
                    for cg in current_groups:
                        for idx, base_name in enumerate(name_list):
                            name = prefix + cg + "_" + base_name
                            description = description_list[0].replace('#','"') if len(description_list) == 1 else description_list[idx].replace('#','\\"')
                            if name in metrics:
                                if description != metrics[name][1]:
                                    verbose(verb, f'Note: Multiple descriptions found for {name}, using first one from {metrics[name][4]}')
                                continue
                            metrics[name] = [typ, description, cg, base_name, file_name + ":" + str(line_number)]
                    current_metric = ""
                    parenthes_count = 0
            else:
                m = gr.match(line)
                if m:
                    current_group = m.group(2)
                    if not current_group:
                        verbose(verb, "empty group found")
                        serching_group = True
                    m = string_content.match(current_group)
                    if m:
                        current_group = m.group(1)
                    else:
                        m = alternative_name.match(current_group)
                        if m:
                            current_group = param_mapping[m.group(1)] if m.group(1) in param_mapping else m.group(1)
                            verbose(verb, "Alternative group", file_name, line_number, current_group)
                m = metrics_directive.match(line)
                if m:
                    param_mapping[m.group(1).strip()] = json.loads(m.group(2))
            line_number += 1
    return metrics

def write_metrics_to_file(out_file, metrics, fmt="pipe"):
    with open(out_file, "a") as fo:
        if fmt == "yml":
            yaml.dump(metrics,fo,sort_keys=False)
        if fmt == "pipe":
            for l in metrics.keys():
                fo.write(l.replace('-','_')+'|' +'|'.join(metrics[l])+ '\n')


def validate_all_metrics(prefix, config_file, verbose=False, strict=True):
    """Validate all metrics files and report issues"""

    print("Validating all metrics files...")

    # Use pathlib to find all .cc files (cross-platform)
    try:
        current_dir = Path('.')
        all_cc_files = list(current_dir.rglob('*.cc'))

        # Filter files that contain '::description'
        metric_files = []
        for cc_file in all_cc_files:
            try:
                with open(cc_file, 'r', encoding='utf-8', errors='ignore') as f:
                    content = f.read()
                    if '::description' in content:
                        # Normalize path to use forward slashes for cross-platform compatibility
                        normalized_path = str(cc_file).replace('\\', '/')
                        metric_files.append(normalized_path)
            except Exception as e:
                if verbose:
                    print(f"[WARN] Could not read {cc_file}: {e}")
                continue

    except Exception as e:
        print(f"[ERROR] Error finding metrics files: {e}")
        return False


    total_files = len(metric_files)

    print(f"Found {total_files} files with metrics")

    failed_files = []
    total_metrics = 0
    metrics_info = get_metrics_information(config_file)

    for file_path in metric_files:
        try:
            metrics = get_metrics_from_file(file_path, prefix, metrics_info, verbose, strict)
            metrics_count = len(metrics)
            total_metrics += metrics_count
            if verbose:
                print(f"[OK] {file_path} - {metrics_count} metrics")
            else:
                print(f"[OK] {file_path}")
        except Exception as e:
            print(f"[ERROR] {file_path}")
            print(f"   Error: {str(e)}")
            failed_files.append((file_path, str(e)))

    if failed_files:
        print("\n[ERROR] METRICS VALIDATION FAILED")
        print("Failed files:")
        for file_path, error in failed_files:
            print(f"   - {file_path}: {error}")
        print(f"\nAdd missing parameters to {config_file}")
        return False
    else:
        working_files = total_files - len(failed_files)
        coverage_pct = (working_files * 100 // total_files) if total_files > 0 else 0

        print(f"\n[SUCCESS] All metrics files validated successfully")
        print(f"   Files: {working_files}/{total_files} working ({coverage_pct}% coverage)")
        print(f"   Metrics: {total_metrics} total processed")
        return True

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='get metrics descriptions from file', conflict_handler="resolve")
    parser.add_argument('-p', '--prefix', default="scylla_", help='the prefix added to the metrics names')
    parser.add_argument('-o', '--out-file', default="metrics.out", help='The output file')
    parser.add_argument('-c', '--config-file', default="metrics-config.yml", help='The configuration file used to add extra data missing in the code')
    parser.add_argument('-v', '--verbose', action='store_true', default=False, help='When set prints verbose information')
    parser.add_argument('-F', '--format', default="pipe", help='Set the output format, can be pipe, or yml')
    parser.add_argument('--validate', action='store_true', help='Validate all metrics files instead of processing single file')
    parser.add_argument('--non-strict', action='store_true', help='Continue with warnings instead of failing on errors (useful for multiversion builds)')
    parser.add_argument('file', nargs='?', help='the file to parse (not needed with --validate)')

    args = parser.parse_args()

    # Determine strict mode
    strict_mode = not args.non_strict

    if args.validate:
        success = validate_all_metrics(args.prefix, args.config_file, args.verbose, strict_mode)
        exit(0 if success else 1)

    if not args.file:
        parser.error('file argument is required when not using --validate')

    metrics = get_metrics_from_file(args.file, args.prefix, get_metrics_information(args.config_file), args.verbose, strict_mode)
    write_metrics_to_file(args.out_file, metrics, args.format)