from flask import Flask, render_template, request, redirect
import yaml
import ast

app = Flask(__name__)

key_type_map = {  
    'work_dir': str,
    'run_name': str,
    'project_cycle': int,
    'run_counter': int,
    'run_option': {
        'out_cat_only': bool,
    },
    'catalog_options': {
        'input_path': {
            'cat_dir': str,
            'star_cat': str,
            'galaxy_cat': str,
        },
        'SED_templates_path': {
            'star_SED': str,
            'galaxy_SED': str,
            'AGN_SED': str,
        },
        'star_only': bool, 
        'galaxy_only': bool,
        'rotateEll': float,
        'enable_mw_ext_gal': bool,
        'planck_ebv_map':str,
    },
    'obs_setting': {
        'pointing_file': str,
        'obs_config_file': str,
        'run_pointings': list,
        'enable_astrometric_model': bool,
        'cut_in_band': str,
        'mag_sat_margin': float,
        'mag_lim_margin': float,
    },
    'psf_setting': {
        'psf_model': str,
        'psf_pho_dir': str,
        'psf_sls_dir': str,
    },
    'shear_setting': {
        'shear_type': str,
        'reduced_g1': float,
        'reduced_g2': float,
    },
    'output_setting': {
        'output_format': str,
        'shutter_output': bool,
        'prnu_output': bool,
    },
    'random_seeds': {
        'seed_poisson': int,
        'seed_CR': int,
        'seed_flat': int,
        'seed_prnu': int,
        'seed_gainNonUniform': int,
        'seed_biasNonUniform': int,
        'seed_rnNonUniform': int,
        'seed_badcolumns': int,
        'seed_defective': int,
        'seed_readout': int,
    },
}


def convert_dict_values(d, key_type_map):  
    for key, value in d.items():  
        if isinstance(value, dict):  
            convert_dict_values(value, key_type_map[key])  
        elif key in key_type_map:  
            if key_type_map[key] is int:
                d[key] = int(value)
            if key_type_map[key] is float:
                d[key] = float(value)
            if key_type_map[key] is bool:
                if d[key].lower() == 'yes' or d[key].lower() == 'true':
                    d[key] = True
                else:
                    d[key] = False
            if key_type_map[key] is str:
                d[key] = str(value)
            if key_type_map[key] is list:
                d[key] = ast.literal_eval(value)


def load_yaml():
    with open('templates/config_overall.yaml', 'r') as file:
        return yaml.safe_load(file)


def save_yaml(data):
    convert_dict_values(data, key_type_map) 
    with open('config_reset/config_overall_reset.yaml', 'w') as file:
        yaml.dump(data, file, default_flow_style=False, sort_keys=False)


def render_form(data, parent_key=''):
    form_html = ''
    for key, value in data.items():
        full_key = f"{parent_key}.{key}" if parent_key else key
        if isinstance(value, dict):  # 处理字典
            form_html += f"<div class='block'><h2>{key}</h2>{render_form(value, full_key)}</div>"
        else:
            form_html += f"<label for='{full_key}'>{key}:</label>"
            form_html += f"<input type='text' id='{full_key}' name='{full_key}' value='{value}'><br>"
    return form_html


@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        data = load_yaml()
        for key in request.form:
            keys = key.split('.')
            temp = data
            for k in keys[:-1]:
                temp = temp[k]
            temp[keys[-1]] = request.form[key]
        save_yaml(data)
        return redirect('/')

    data = load_yaml()
    form_html = render_form(data)
    return render_template('index_overall.html', form_html=form_html)


if __name__ == '__main__':
    app.run(debug=True)