# Copyright 2020-2022 Efabless Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

package require json
package require openlane_utils


proc save_state {args} {
    set ::env(INIT_ENV_VAR_ARRAY) [split [array names ::env] " "]
    puts_info "Saving runtime environment..."
    set_log ::env(PDK_ROOT) $::env(PDK_ROOT) $::env(GLB_CFG_FILE) 1
    foreach index [lsort [array names ::env]] {
        if { $index != "INIT_ENV_VAR_ARRAY" && $index != "PS1" } {
            set escaped_env_var [string map {\" \\\"} $::env($index)]
            set escaped_env_var [string map {\$ \\\$} $escaped_env_var]
            set_log ::env($index) $escaped_env_var $::env(GLB_CFG_FILE) 1
        }
    }
}

proc set_netlist {netlist args} {
    set options {}

    set flags {
        -lec
    }
    set args_copy $args

    parse_key_args "set_netlist" args arg_values $options flags_map $flags

    set netlist_relative [relpath . $netlist]

    puts_verbose "Changing netlist to '$netlist_relative'..."

    set ::env(PREV_NETLIST) $::env(CURRENT_NETLIST)
    set ::env(CURRENT_NETLIST) $netlist

    set replace [string map {/ \\/} $::env(CURRENT_NETLIST)]
    try_catch sed -i -e "s/\\(set ::env(CURRENT_NETLIST)\\).*/\\1 $replace/" "$::env(GLB_CFG_FILE)"

    set replace [string map {/ \\/} $::env(PREV_NETLIST)]
    try_catch sed -i -e "s/\\(set ::env(PREV_NETLIST)\\).*/\\1 $replace/" "$::env(GLB_CFG_FILE)"

    if { [info exists flags_map(-lec)] && [file exists $::env(PREV_NETLIST)] } {
        logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
    }
}

proc set_def {def} {
    set def_relative [relpath . $def]
    puts_verbose "Changing layout to '$def_relative'..."
    set ::env(CURRENT_DEF) $def
    set replace [string map {/ \\/} $def]
    exec sed -i -e "s/\\(set ::env(CURRENT_DEF)\\).*/\\1 $replace/" "$::env(GLB_CFG_FILE)"
}

proc set_guide {guide} {
    set guide_relative [relpath . $guide]
    puts_verbose "Changing guide to '$guide_relative'..."
    set ::env(CURRENT_GUIDE) $guide
    set replace [string map {/ \\/} $guide]
    exec sed -i -e "s/\\(set ::env(CURRENT_GUIDE)\\).*/\\1 $replace/" "$::env(GLB_CFG_FILE)"
}

proc prep_lefs {args} {
    set options {
        {-tech_lef optional}
        {-cell_lef optional}
        {-corner optional}
        {-env_var optional}
    }

    set flags {-no_widen}

    parse_key_args "prep_lefs" args arg_values $options flags_map $flags

    set_if_unset arg_values(-tech_lef) $::env(TECH_LEF)
    set_if_unset arg_values(-cell_lef) $::env(CELLS_LEF)
    set_if_unset arg_values(-env_var) MERGED_LEF
    set_if_unset arg_values(-corner) nom

    if { ![file exists $arg_values(-tech_lef)] } {
        if { $arg_values(-env_var) == "MERGED_LEF" } {
            puts_err "Nominal process corner '$arg_values(-tech_lef)' not found."
            return -code error
        }
        puts_info "'$arg_values(-tech_lef)' not found, skipping..."
        return
    }
    puts_info "Preparing LEF files for the $arg_values(-corner) corner..."

    if { $arg_values(-corner) == "nom" } {
        puts_verbose "Extracting the number of available metal layers from $arg_values(-tech_lef)"

        set ::env(TECH_METAL_LAYERS)  [exec python3 $::env(SCRIPTS_DIR)/extract_metal_layers.py $arg_values(-tech_lef)]
        set ::env(MAX_METAL_LAYER) [llength $::env(TECH_METAL_LAYERS)]

        puts_verbose "The available metal layers ($::env(MAX_METAL_LAYER)) are $::env(TECH_METAL_LAYERS)"
        puts_verbose "Merging LEF Files..."
    }

    set mlu $::env(TMP_DIR)/merged.unpadded.$arg_values(-corner).lef

    try_catch $::env(SCRIPTS_DIR)/mergeLef.py\
        -o $mlu\
        -i $arg_values(-tech_lef) $arg_values(-cell_lef)\
        |& tee $::env(TERMINAL_OUTPUT)

    set mlu_relative [relpath . $mlu]
    puts_verbose "Created merged LEF without pads at '$mlu_relative'..."

    # Merged Extra Lefs (if they exist)
    if { [info exist ::env(EXTRA_LEFS)] } {
        try_catch $::env(SCRIPTS_DIR)/mergeLef.py\
            -o $mlu\
            -i $mlu {*}$::env(EXTRA_LEFS)\
            |& tee $::env(TERMINAL_OUTPUT)
        puts_verbose "Added extra lefs to '$mlu_relative'..."
    }

    # Merge optimization TLEF/CLEF (if exists)
    if { [info exist ::env(STD_CELL_LIBRARY_OPT)] && $::env(STD_CELL_LIBRARY_OPT) != $::env(STD_CELL_LIBRARY) } {
        try_catch $::env(SCRIPTS_DIR)/mergeLef.py\
            -o $mlu\
            -i $mlu $::env(TECH_LEF_OPT) {*}$::env(CELLS_LEF_OPT) |& tee $::env(TERMINAL_OUTPUT)
        puts_verbose "Added optimization library tech lef and cell lefs to '$mlu_relative'..."
    }

    # Merge pads (if GPIO_PADS_LEF exists)
    set ml $::env(TMP_DIR)/merged.$arg_values(-corner).lef
    set ml_relative [relpath . $ml]
    if { $::env(USE_GPIO_PADS) } {
        if { [info exists ::env(USE_GPIO_ROUTING_LEF)] && $::env(USE_GPIO_ROUTING_LEF)} {
            set ::env(GPIO_PADS_LEF) $::env(GPIO_PADS_LEF_CORE_SIDE)
        }

        puts_verbose "Merging the following GPIO LEF views: $::env(GPIO_PADS_LEF)..."
        try_catch $::env(SCRIPTS_DIR)/mergeLef.py\
            -o $ml\
            -i $mlu {*}$::env(GPIO_PADS_LEF)
        puts_verbose "Created '$ml_relative' with gpio pads."
    } else {
        file copy -force $mlu $ml
        puts_verbose "Created '$ml_relative' unaltered."
    }

    set ::env($arg_values(-env_var)_UNPADDED) $mlu
    set ::env($arg_values(-env_var)) $ml

    if { ![info exists flags_map(-no_widen)] } {
        widen_site_width
        use_widened_lefs
    }
}

proc gen_exclude_list {args} {
    puts_verbose "Generating cell exclude list..."
    set options {
        {-lib required}
        {-drc_exclude_list optional}
        {-synth_exclude_list optional}
        {-output optional}
    }
    set flags {
        -drc_exclude_only
        -create_dont_use_list
    }
    parse_key_args "gen_exclude_list" args arg_values $options flags_map $flags

    set_if_unset arg_values(-drc_exclude_list) $::env(DRC_EXCLUDE_CELL_LIST)
    set_if_unset arg_values(-synth_exclude_list) $::env(NO_SYNTH_CELL_LIST)
    set_if_unset arg_values(-output) $arg_values(-lib).exclude.list

    # Copy the drc exclude list into the run directory, if it exists.
    foreach list_file $arg_values(-drc_exclude_list) {
        set out  [open $arg_values(-output) a]
        if { [file exists $list_file] } {
            set in [open $list_file]
            fcopy $in $out
            close $in
        }
        close $out
    }

    # If you're not told to only use the drc exclude list, and if the no_synth.cells exists, merge the two lists
    if { (![info exists flags_map(-drc_exclude_only)]) && [file exists $arg_values(-synth_exclude_list)] } {
        set out [open $arg_values(-output) a]
        set in [open $arg_values(-synth_exclude_list)]
        fcopy $in $out
        close $in
        close $out
    }

    if { [file exists $arg_values(-output)] && [info exists flags_map(-create_dont_use_list)] } {
        puts_verbose "Creating ::env(DONT_USE_CELLS)..."
        set x [cat "$arg_values(-output)"]
        set y [split $x]
        set ::env(DONT_USE_CELLS) [join $y " "]
    }


}

proc trim_lib {args} {
    puts_verbose "Trimming Liberty..."
    set options {
        {-input optional}
        {-output optional}
    }
    set flags {
        -drc_exclude_only
    }
    parse_key_args "trim_lib" args arg_values $options flags_map $flags
    set_if_unset arg_values(-input) $::env(LIB_SYNTH_COMPLETE)
    set_if_unset arg_values(-output) $::env(LIB_SYNTH)

    if { [info exists flags_map(-drc_exclude_only)] } {
        gen_exclude_list -lib $arg_values(-output) -drc_exclude_only
    } else {
        gen_exclude_list -lib $arg_values(-output)
    }

    # Trim the liberty with the generated list, if it exists.
    if { ! [file exists $arg_values(-output).exclude.list] } {
        set fid [open $arg_values(-output).exclude.list w]
        close $fid
    }

    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/libtrim.py\
        --cell-file $arg_values(-output).exclude.list\
        --output $arg_values(-output)\
        $arg_values(-input)
}

proc source_config {config_file} {
    puts_info "Sourcing Configurations from $config_file"
    if { ![file exists $config_file] } {
        puts_err "Configuration file $config_file not found"
        return -code error
    }
    if { [file extension $config_file] == ".tcl" } {
        # for trusted end-users only
        source $config_file
    } elseif { [file extension $config_file] == ".json" } {
        set config_content [cat $config_file]

        if { [catch {json::json2dict "$config_content"} config_dict] } {
            puts_err "Failed to parse JSON file $config_file"
            return -code error
        }
        dict for {config_key config_value} $config_dict {
            # TODO after refactor: check if config_key is a valid configuration
            set ::env($config_key) $config_value
        }
    } else {
        puts_err "Configuration file $config_file with invalid extension"
        return -code error
    }

    return -code ok
}

proc prep {args} {

    set ::env(timer_start) [clock seconds]
    TIMER::timer_start
    set options {
        {-design required}
        {-tag optional}
        {-config_tag optional}
        {-config_file optional}
        {-run_path optional}
        {-src optional}
        {-override_env optional}
        {-verbose optional}
    }

    set flags {
        -init_design_config
        -overwrite
        -last_run
    }

    set args_copy $args
    parse_key_args "prep" args arg_values $options flags_map $flags

    # Storing the current state of environment variables
    set ::env(INIT_ENV_VAR_ARRAY) [split [array names ::env] " "]

    if { [info exists arg_values(-config_tag)] } {
        if { [info exists arg_values(-config_file)] } {
            puts_err "Cannot specify both -config_tag and -config_file"
            return -code error
        }
        set config_tag $arg_values(-config_tag)
    } else {
        set config_tag "config"
    }
    set src_files ""

    set ::env(DESIGN_DIR) [file normalize $arg_values(-design)]
    if { ![file exists $::env(DESIGN_DIR)] } {
        set ::env(DESIGN_DIR) [file normalize $::env(OPENLANE_ROOT)/designs/$arg_values(-design)]
    }

    if { [info exists flags_map(-init_design_config)] } {
        set config_tag "config"
        if { [info exists arg_values(-tag) ] } {
            set config_tag $arg_values(-tag)
        }

        if { [info exists arg_values(-src) ] } {
            set src_files $arg_values(-src)
        }

        init_design $arg_values(-design) $config_tag $src_files
        puts_success "Done..."
        exit 0
    }

    set_if_unset arg_values(-verbose) "0"
    set ::env(OPENLANE_VERBOSE) $arg_values(-verbose)


    set ::env(TERMINAL_OUTPUT) "/dev/null"
    if { $::env(OPENLANE_VERBOSE) >= 2 } {
        set ::env(TERMINAL_OUTPUT) ">&@stdout"
    }

    set ::env(START_TIME) [clock format [clock seconds] -format %Y.%m.%d_%H.%M.%S ]

    if { [info exists flags_map(-last_run)] } {
        if { [info exists arg_values(-tag)] } {
            puts_err "Cannot specify a tag with -last_run set."
            return -code error
        }

        set arg_values(-tag) [exec python3 ./scripts/most_recent_run.py $::env(DESIGN_DIR)/runs]
    }

    set_if_unset arg_values(-tag) "RUN_$::env(START_TIME)"
    set tag $arg_values(-tag)


    set ::env(CONFIGS) [glob $::env(OPENLANE_ROOT)/configuration/*.tcl]

    if { [info exists arg_values(-config_file)] } {
        set ::env(DESIGN_CONFIG) $arg_values(-config_file)
    } else {
        if { [file exists $::env(DESIGN_DIR)/$config_tag.tcl] } {
            set ::env(DESIGN_CONFIG) $::env(DESIGN_DIR)/$config_tag.tcl
        } else {
            set ::env(DESIGN_CONFIG) $::env(DESIGN_DIR)/$config_tag.json
        }
    }

    if { ! [file exists $::env(DESIGN_CONFIG)] } {
        puts_err "No design configuration found at $::env(DESIGN_CONFIG)"
        return -code error
    }

    puts_info "Using design configuration at $::env(DESIGN_CONFIG)"

    foreach config $::env(CONFIGS) {
        source $config
    }

    # needs to be sourced first since it can choose to determine the PDK and SCL
    source_config $::env(DESIGN_CONFIG)

    if { [info exists arg_values(-override_env)] } {
        set env_overrides [split $arg_values(-override_env) ',']
        foreach override $env_overrides {
            set kva [split $override '=']
            set key [lindex $kva 0]
            set value [lindex $kva 1]
            set ::env(${key}) $value
        }
    }


    # DEPRECATED PDK_VARIANT
    handle_deprecated_config PDK_VARIANT STD_CELL_LIBRARY

    # Diagnostics
    if { ! [info exists ::env(PDK_ROOT)] || $::env(PDK_ROOT) == "" } {
        puts_err "PDK_ROOT is not specified. Please make sure you have it set."
        return -code error
    } else {
        puts_info "PDKs root directory: $::env(PDK_ROOT)"
    }

    if { ! [info exists ::env(PDK)] } {
        puts_err "PDK is not specified."
        return -code error
    } else {
        puts_info "PDK: $::env(PDK)"
        puts_info "Setting PDKPATH to $::env(PDK_ROOT)/$::env(PDK)"
        set ::env(PDKPATH) $::env(PDK_ROOT)/$::env(PDK)
    }

    if { ! [info exists ::env(STD_CELL_LIBRARY)] } {
        puts_err "STD_CELL_LIBRARY is not specified."
        return -code error
    } else {
        puts_info "Standard Cell Library: $::env(STD_CELL_LIBRARY)"
    }

    if { ! [info exists ::env(STD_CELL_LIBRARY_OPT)] } {
        set ::env(STD_CELL_LIBRARY_OPT) $::env(STD_CELL_LIBRARY)
        puts_info "Optimization Standard Cell Library is set to: $::env(STD_CELL_LIBRARY_OPT)"
    } else {
        puts_info "Optimization Standard Cell Library: $::env(STD_CELL_LIBRARY_OPT)"
    }

    if {![info exists ::env(PDN_CFG)]} {
        set ::env(PDN_CFG) $::env(SCRIPTS_DIR)/openroad/pdn_cfg.tcl
    }

    # source PDK and SCL specific configurations
    set pdk_config $::env(PDK_ROOT)/$::env(PDK)/libs.tech/openlane/config.tcl
    set scl_config $::env(PDK_ROOT)/$::env(PDK)/libs.tech/openlane/$::env(STD_CELL_LIBRARY)/config.tcl
    source $pdk_config

    # Value set by PDK for some reason
    if { [info exists ::env(GLB_RT_L1_ADJUSTMENT) ] } {
        unset ::env(GLB_RT_L1_ADJUSTMENT)
    }

    source $scl_config

    # needs to be resourced to make sure it overrides the above
    source_config $::env(DESIGN_CONFIG)

    # DEPRECATED CONFIGS
    handle_deprecated_config LIB_MIN LIB_FASTEST;
    handle_deprecated_config LIB_MAX LIB_SLOWEST;
    handle_deprecated_config CELL_PAD_EXECLUDE CELL_PAD_EXCLUDE;
    handle_deprecated_config ROUTING_OPT_ITERS DRT_OPT_ITERS;
    handle_deprecated_config FP_HORIZONTAL_HALO FP_PDN_HORIZONTAL_HALO;
    handle_deprecated_config FP_VERTICAL_HALO FP_PDN_VERTICAL_HALO;

    if { [info exists arg_values(-run_path)] } {
        set run_path "[file normalize $arg_values(-run_path)]/$tag"
    } else {
        set run_path $::env(DESIGN_DIR)/runs/$tag
    }


    #
    ############################
    # Prep directories and files
    ############################
    #
    set ::env(RUN_TAG)		"$tag"
    set ::env(RUN_DIR) 		"$run_path"
    set ::env(RESULTS_DIR) 	"$::env(RUN_DIR)/results"
    set ::env(TMP_DIR) 		"$::env(RUN_DIR)/tmp"
    set ::env(LOGS_DIR) 		"$::env(RUN_DIR)/logs"
    set ::env(REPORTS_DIR) 	"$::env(RUN_DIR)/reports"
    set ::env(GLB_CFG_FILE) 	"$::env(RUN_DIR)/config.tcl"

    set skip_basic_prep 0

    if { [file exists $::env(RUN_DIR)] } {
        if { [info exists flags_map(-overwrite)] } {
            puts_warn "Removing existing run at $::env(RUN_DIR)..."
            after 1000
            file delete -force $::env(RUN_DIR)
        } elseif { ![info exists flags_map(-last_run)] } {
            puts_warn "A run for $::env(DESIGN_NAME) with tag '$tag' already exists. Pass the -overwrite option to overwrite it."
            after 1000
            set skip_basic_prep 1
        }
    }


    # file mkdir *ensures* they exists (no problem if they already do)
    file mkdir $::env(RESULTS_DIR) $::env(TMP_DIR) $::env(LOGS_DIR) $::env(REPORTS_DIR)

    puts_info "Current run directory is $::env(RUN_DIR)"

    if { [file exists $::env(GLB_CFG_FILE)] } {
        if { [info exists flags_map(-overwrite)] } {
            puts_info "Removing $::env(GLB_CFG_FILE)"
            file delete $::env(GLB_CFG_FILE)
        } else {
            puts_info "Sourcing $::env(GLB_CFG_FILE)\nAny changes to the DESIGN config file will NOT be applied"
            source $::env(GLB_CFG_FILE)
            if { [info exists ::env(CURRENT_DEF)] && $::env(CURRENT_DEF) != 0 } {
                puts_info "Current DEF: $::env(CURRENT_DEF)."
                puts_info "Use 'set_def file_name.def' if you'd like to change it."
            }
            after 1000
        }
    }


    set run_subfolder_structure [list \
        synthesis\
        floorplan\
        placement\
        cts\
        routing\
        eco\
        signoff
    ]

    foreach subfolder $run_subfolder_structure {

        set ::env(${subfolder}_reports) $::env(REPORTS_DIR)/$subfolder
        file mkdir $::env(${subfolder}_reports)

        set ::env(${subfolder}_logs) $::env(LOGS_DIR)/$subfolder
        file mkdir $::env(${subfolder}_logs)

        set ::env(${subfolder}_tmpfiles) $::env(TMP_DIR)/$subfolder
        file mkdir $::env(${subfolder}_tmpfiles)

        set ::env(${subfolder}_results) $::env(RESULTS_DIR)/$subfolder
        file mkdir $::env(${subfolder}_results)
    }

    set util 	$::env(FP_CORE_UTIL)
    set density $::env(PL_TARGET_DENSITY)

    # Fill config file
    puts_verbose "Storing configs into config.tcl ..."
    exec echo "# Run configs" > $::env(GLB_CFG_FILE)
    set_log ::env(PDK_ROOT) $::env(PDK_ROOT) $::env(GLB_CFG_FILE) 1
    foreach index [lsort [array names ::env]] {
        if { $index != "INIT_ENV_VAR_ARRAY" } {
            if { $index ni $::env(INIT_ENV_VAR_ARRAY) } {
                set_log ::env($index) $::env($index) $::env(GLB_CFG_FILE) 1
            }
        }
    }

    # Process LEFs and LIB files
    if { ! $skip_basic_prep } {
        prep_lefs -tech_lef $::env(TECH_LEF) -corner nom -env_var MERGED_LEF

        if { [info exists ::env(TECH_LEF_MIN)] } {
            prep_lefs -tech_lef $::env(TECH_LEF_MIN) -corner min -env_var MERGED_LEF_MIN -no_widen
        }
        if { [info exists ::env(TECH_LEF_MAX)] } {
            prep_lefs -tech_lef $::env(TECH_LEF_MAX) -corner max -env_var MERGED_LEF_MAX -no_widen
        }

        set ::env(LIB_SYNTH_COMPLETE) $::env(LIB_SYNTH)
        # merge synthesis libraries
        set ::env(LIB_SYNTH_MERGED) $::env(synthesis_tmpfiles)/merged.lib
        try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/mergeLib.py\
            --output $::env(LIB_SYNTH_MERGED)\
            --name $::env(PDK)_merged\
            {*}$::env(LIB_SYNTH_COMPLETE)

        # trim synthesis library
        set ::env(LIB_SYNTH) $::env(synthesis_tmpfiles)/trimmed.lib
        trim_lib -input $::env(LIB_SYNTH_MERGED)

        # trim resizer library
        if { ! [info exists ::env(LIB_RESIZER_OPT) ] } {
            set ::env(LIB_RESIZER_OPT) [list]
            foreach lib $::env(LIB_SYNTH_COMPLETE) {
                set fbasename [file rootname [file tail $lib]]
                set lib_resizer $::env(synthesis_tmpfiles)/resizer_$fbasename.lib
                file copy -force $lib $lib_resizer
                lappend ::env(LIB_RESIZER_OPT) $lib_resizer
            }

            if { $::env(STD_CELL_LIBRARY_OPT) != $::env(STD_CELL_LIBRARY) } {
                foreach lib $::env(LIB_SYNTH_OPT) {
                    set fbasename [file rootname [file tail $lib]]
                    set lib_resizer $::env(synthesis_tmpfiles)/resizer_opt_$fbasename.lib
                    file copy -force $lib $lib_resizer
                    lappend ::env(LIB_RESIZER_OPT) $lib_resizer
                }
            }
        }

        if { ! [info exists ::env(DONT_USE_CELLS)] } {
            if { $::env(STD_CELL_LIBRARY_OPT) != $::env(STD_CELL_LIBRARY) } {
                set drc_exclude_list "$::env(DRC_EXCLUDE_CELL_LIST) $::env(DRC_EXCLUDE_CELL_LIST_OPT)"
            } else {
                set drc_exclude_list "$::env(DRC_EXCLUDE_CELL_LIST)"
            }
            gen_exclude_list -lib resizer_opt -drc_exclude_list $drc_exclude_list -output $::env(synthesis_tmpfiles)/resizer_opt.exclude.list -drc_exclude_only -create_dont_use_list
        }

        if { $::env(USE_GPIO_PADS) } {
            if { ! [info exists ::env(VERILOG_FILES_BLACKBOX)] } {
                set ::env(VERILOG_FILES_BLACKBOX) ""
            }
            if { [info exists ::env(GPIO_PADS_VERILOG)] } {
                lappend ::env(VERILOG_FILES_BLACKBOX) {*}$::env(GPIO_PADS_VERILOG)
            } else {
                puts_warn "GPIO_PADS_VERILOG is not set; cannot read as a blackbox"
            }
        }
    }

    # Fill config file with special cases
    if { ! [info exists ::env(SYNTH_MAX_TRAN)] } {
        if { [info exists ::env(CLOCK_PERIOD)] } {
            if { [info exists ::env(DEFAULT_MAX_TRAN)] } {
                set ::env(SYNTH_MAX_TRAN) [expr min([expr {0.1*$::env(CLOCK_PERIOD)}], $::env(DEFAULT_MAX_TRAN))]
            } else {
                set ::env(SYNTH_MAX_TRAN) [expr {0.1*$::env(CLOCK_PERIOD)}]
            }
        } else {
            set ::env(SYNTH_MAX_TRAN) 0
        }
        set_log ::env(SYNTH_MAX_TRAN) $::env(SYNTH_MAX_TRAN) $::env(GLB_CFG_FILE) 1
    }
    if { $::env(SYNTH_TOP_LEVEL) } {
        set_log ::env(SYNTH_SCRIPT) "$::env(SCRIPTS_DIR)/yosys/synth_top.tcl" $::env(GLB_CFG_FILE) 0
    }
    set_log ::env(SYNTH_OPT) 0 $::env(GLB_CFG_FILE) 0
    set_log ::env(PL_INIT_COEFF) 0.00002 $::env(GLB_CFG_FILE) 0
    set_log ::env(PL_IO_ITER) 5 $::env(GLB_CFG_FILE) 0

    if { ! [info exists ::env(CURRENT_DEF)] } {
        set ::env(CURRENT_DEF) 0
        set_log ::env(CURRENT_DEF) $::env(CURRENT_DEF) $::env(GLB_CFG_FILE) 1
    }

    if { ! [info exists ::env(CURRENT_GUIDE)] } {
        set ::env(CURRENT_GUIDE) 0
        set_log ::env(CURRENT_GUIDE) $::env(CURRENT_GUIDE) $::env(GLB_CFG_FILE) 1
    }

    if { ! [info exists ::env(CURRENT_INDEX)] } {
        set ::env(CURRENT_INDEX) 0
        set_log ::env(CURRENT_INDEX) $::env(CURRENT_INDEX) $::env(GLB_CFG_FILE) 1
    }

    if { ! [info exists ::env(CURRENT_NETLIST)] } {
        set ::env(CURRENT_NETLIST) 0
        set_log ::env(CURRENT_NETLIST) $::env(CURRENT_NETLIST) $::env(GLB_CFG_FILE) 1
    }

    if { ! [info exists ::env(PREV_NETLIST)] } {
        set ::env(PREV_NETLIST) 0
        set_log ::env(PREV_NETLIST) $::env(PREV_NETLIST) $::env(GLB_CFG_FILE) 1
    }

    if { [file exists $::env(PDK_ROOT)/$::env(PDK)/SOURCES] } {
        file copy -force $::env(PDK_ROOT)/$::env(PDK)/SOURCES $::env(RUN_DIR)/PDK_SOURCES
    }
    if { [info exists ::env(OPENLANE_VERSION) ] } {
        try_catch echo "openlane $::env(OPENLANE_VERSION)" > $::env(RUN_DIR)/OPENLANE_VERSION
    }

    # Convert Tracks
    if { $::env(TRACKS_INFO_FILE) != "" } {
        set tracks_processed $::env(routing_tmpfiles)/config.tracks
        try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/new_tracks.py -i $::env(TRACKS_INFO_FILE) -o $tracks_processed
        set ::env(TRACKS_INFO_FILE_PROCESSED) $tracks_processed
    }

    if { [info exists ::env(EXTRA_GDS_FILES)] } {
        puts_info "Looking for files defined in ::env(EXTRA_GDS_FILES) $::env(EXTRA_GDS_FILES) ..."
        assert_files_exist $::env(EXTRA_GDS_FILES)
    }


    if [catch {exec python3 $::env(OPENLANE_ROOT)/dependencies/verify_versions.py} ::env(VCHECK_OUTPUT)] {
        if { $::env(QUIT_ON_MISMATCHES) == "1" } {
            puts_err $::env(VCHECK_OUTPUT)
            puts_err "Please update your environment. OpenLane will now quit."
            flow_fail
            return -code error
        }
        
        puts_warn "OpenLane may not function properly: $::env(VCHECK_OUTPUT)"
    }

    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "openlane design prep"
    return -code ok
}

proc padframe_gen {args} {
    puts_info "Generating Padframe..."
    set options {{-folder required}}
    set flags {}
    parse_key_args "padframe_gen" args arg_values $options flags_map $flags
    set pf_src_tmp [file normalize $arg_values(-folder)]
    #
    set pfg_exec $::env(SCRIPTS_DIR)/padframe_generator.py
    #   set pf_src $::env(DESIGN_DIR)/src
    #   set pf_src_tmp $::env(TMP_DIR)/src
    #   file copy $pf_src $pf_src_tmp

    fake_display_buffer

    exec $pfg_exec -nogui -tech-path=$::env(PDK_ROOT)/$::env(PDK) \
        -project-path=$pf_src_tmp -cfg \
        |& tee $::env(TERMINAL_OUTPUT) [index_file $pf_src_tmp/pfg.log]
    kill_display_buffer
}

proc padframe_gen_legacy {args} {
    set pfg_exec $::env(SCRIPTS_DIR)/padframe_generator.py
    set pf_src $::env(DESIGN_DIR)/src
    set pf_src_tmp $::env(TMP_DIR)/src
    file copy $pf_src $pf_src_tmp

    fake_display_buffer

    exec $pfg_exec -nogui -tech-path=$::env(PDK_ROOT)/$::env(PDK) \
        -project-path=$pf_src_tmp -cfg \
        |& tee $::env(TERMINAL_OUTPUT) [index_file $pf_src_tmp/pfg.log]
    kill_display_buffer
}


proc save_views {args} {
    set options {
        {-lef_path optional}
        {-mag_path optional}
        {-maglef_path optional}
        {-def_path optional}
        {-gds_path optional}
        {-verilog_path optional}
        {-spice_path optional}
        {-sdf_path optional}
        {-spef_path optional}
        {-sdc_path optional}
        {-save_path optional}
    }

    set flags {}
    parse_key_args "save_views" args arg_values $options flags_map $flags
    if { [info exists arg_values(-save_path)]\
        && $arg_values(-save_path) != "" } {
        set path "[file normalize $arg_values(-save_path)]"
    } else {
        set path $::env(RESULTS_DIR)/final
    }
    puts_info "Saving final set of views in '$path'..."

    if { [info exists arg_values(-lef_path)] } {
        set destination $path/lef
        file mkdir $destination
        if { [file exists $arg_values(-lef_path)] } {
            file copy -force $arg_values(-lef_path) $destination/$::env(DESIGN_NAME).lef
        }
    }

    if { [info exists arg_values(-mag_path)] } {
        set destination $path/mag
        file mkdir $destination
        if { [file exists $arg_values(-mag_path)] } {
            file copy -force $arg_values(-mag_path) $destination/$::env(DESIGN_NAME).mag
        }
    }

    if { [info exists arg_values(-maglef_path)] } {
        set destination $path/maglef
        file mkdir $destination
        if { [file exists $arg_values(-maglef_path)] } {
            file copy -force $arg_values(-maglef_path) $destination/$::env(DESIGN_NAME).mag
        }
    }

    if { [info exists arg_values(-def_path)] } {
        set destination $path/def
        file mkdir $destination
        if { [file exists $arg_values(-def_path)] } {
            file copy -force $arg_values(-def_path) $destination/$::env(DESIGN_NAME).def
        }
    }

    if { [info exists arg_values(-gds_path)] } {
        set destination $path/gds
        file mkdir $destination
        if { [file exists $arg_values(-gds_path)] } {
            file copy -force $arg_values(-gds_path) $destination/$::env(DESIGN_NAME).gds
        }
    }
    if { [info exists arg_values(-verilog_path)] } {
        set destination $path/verilog/gl
        file mkdir $destination
        if { [file exists $arg_values(-verilog_path)] } {
            file copy -force $arg_values(-verilog_path) $destination/$::env(DESIGN_NAME).v
        }
    }

    if { [info exists arg_values(-spice_path)] } {
        set destination $path/spi/lvs
        file mkdir $destination
        if { [file exists $arg_values(-spice_path)] } {
            file copy -force $arg_values(-spice_path) $destination/$::env(DESIGN_NAME).spice
        }
    }

    if { [info exists arg_values(-spef_path)] } {
        set destination $path/spef
        file mkdir $destination
        if { [file exists $arg_values(-spef_path)] } {
            file copy -force $arg_values(-spef_path) $destination/$::env(DESIGN_NAME).spef
        }
    }

    if { [info exists arg_values(-sdf_path)] } {
        set destination $path/sdf
        file mkdir $destination
        if { [file exists $arg_values(-sdf_path)] } {
            file copy -force $arg_values(-sdf_path) $destination/$::env(DESIGN_NAME).sdf
        }
    }

    if { [info exists arg_values(-sdc_path)] } {
        set destination $path/sdc
        file mkdir $destination
        if { [file exists $arg_values(-sdc_path)] } {
            file copy -force $arg_values(-sdc_path) $destination/$::env(DESIGN_NAME).sdc
        }
    }
}


# to be done after detailed routing and run_magic_antenna_check
proc heal_antenna_violators {args} {
    # requires a pre-existing report containing a list of cells (-pins?)
    # that need the real diode in place of the fake diode:
    # => fixes the routed def
    if { ($::env(DIODE_INSERTION_STRATEGY) == 2) || ($::env(DIODE_INSERTION_STRATEGY) == 5) } {
        increment_index
        TIMER::timer_start
        puts_info "Healing Antenna Violators..."
        if { $::env(USE_ARC_ANTENNA_CHECK) == 1 } {
            #ARC specific
            if { [info exists ::env(ANTENNA_CHECKER_LOG)] } {
                try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/extract_antenna_violators.py -i $::env(ANTENNA_CHECKER_LOG) -o [index_file $::env(routing_reports)/violators.txt]
            } else {
                puts_err "Ran heal_antenna_violators without running the antenna check first."
                flow_fail
            }
        } else {
            #Magic Specific
            set report_file [open [index_file $::env(routing_reports)/antenna_violators.rpt] r]
            set violators [split [string trim [read $report_file]]]
            close $report_file
            # may need to speed this up for extremely huge files using hash tables
            exec echo $violators >> [index_file $::env(routing_reports)/violators.txt]
        }
        #replace violating cells with real diodes
        try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/fake_diode_replace.py -v [index_file $::env(routing_reports)/violators.txt] -d $::env(routing_results)/$::env(DESIGN_NAME).def -f $::env(FAKEDIODE_CELL) -t $::env(DIODE_CELL)
        TIMER::timer_stop
        exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "heal antenna violators - custom"
    }
}

proc widen_site_width {args} {
    set ::env(MERGED_LEF_UNPADDED_ORIGINAL) $::env(MERGED_LEF_UNPADDED)
    set ::env(MERGED_LEF_ORIGINAL) $::env(MERGED_LEF)

    if { $::env(WIDEN_SITE) == 1 && $::env(WIDEN_SITE_IS_FACTOR) == 1 } {
        set ::env(MERGED_LEF_UNPADDED_WIDENED) $::env(MERGED_LEF_UNPADDED)
        set ::env(MERGED_LEF_WIDENED) $::env(MERGED_LEF)
    } else {
        puts_info "Widenning Site Width..."
        set ::env(MERGED_LEF_UNPADDED_WIDENED) $::env(TMP_DIR)/merged_unpadded_wider.lef
        set ::env(MERGED_LEF_WIDENED) $::env(TMP_DIR)/merged_wider.lef
        if { $::env(WIDEN_SITE_IS_FACTOR) == 1 } {
            try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/widen_site_lef.py -l $::env(MERGED_LEF_UNPADDED) -w $::env(WIDEN_SITE) -f -o $::env(MERGED_LEF_UNPADDED_WIDENED)
            try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/widen_site_lef.py -l $::env(MERGED_LEF) -w $::env(WIDEN_SITE) -f -o $::env(MERGED_LEF_WIDENED)

        } else {
            try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/widen_site_lef.py -l $::env(MERGED_LEF_UNPADDED) -w $::env(WIDEN_SITE) -o $::env(MERGED_LEF_UNPADDED_WIDENED)
            try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/widen_site_lef.py -l $::env(MERGED_LEF) -w $::env(WIDEN_SITE) -o $::env(MERGED_LEF_WIDENED)
        }
    }
}

proc use_widened_lefs {args} {
    if { $::env(WIDEN_SITE) != 1 || $::env(WIDEN_SITE_IS_FACTOR) != 1 } {
        set ::env(MERGED_LEF_UNPADDED) $::env(MERGED_LEF_UNPADDED_WIDENED)
        set ::env(MERGED_LEF) $::env(MERGED_LEF_WIDENED)
    }
}

proc use_original_lefs {args} {
    if { $::env(WIDEN_SITE) != 1 || $::env(WIDEN_SITE_IS_FACTOR) != 1 } {
        set ::env(MERGED_LEF_UNPADDED) $::env(MERGED_LEF_UNPADDED_ORIGINAL)
        set ::env(MERGED_LEF) $::env(MERGED_LEF_ORIGINAL)
    }
}


proc label_macro_pins {args} {
    TIMER::timer_start
    puts_info "Labeling macro pins..."
    set options {
        {-lef required}
        {-netlist_def required}
        {-pad_pin_name optional}
        {-output optional}
        {-extra_args optional}
    }
    set flags {}
    parse_key_args "label_macro_pins" args arg_values $options flags_map $flags

    set output_def $::env(CURRENT_DEF)
    set extra_args ""

    if {[info exists arg_values(-output)]} {
        set output_def $arg_values(-output)
    }

    if {[info exists arg_values(-extra_args)]} {
        set extra_args $arg_values(-extra_args)
    }

    set_if_unset arg_values(-pad_pin_name) ""

    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/label_macro_pins.py\
        --lef $arg_values(-lef)\
        --input-def $::env(CURRENT_DEF)\
        --netlist-def $arg_values(-netlist_def)\
        --pad-pin-name $arg_values(-pad_pin_name)\
        -o $output_def\
        {*}$extra_args |& tee [index_file $::env(signoff_logs)/label_macro_pins.log] $::env(TERMINAL_OUTPUT)
    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "label macro pins - label_macro_pins.py"
}


proc write_verilog {filename args} {
    increment_index
    TIMER::timer_start
    puts_info "Writing Verilog..."
    set ::env(SAVE_NETLIST) $filename

    set options {
        {-def optional}
        {-log optional}
    }
    set flags {
        -canonical
    }
    parse_key_args "write_verilog" args arg_values $options flags_map $flags

    set_if_unset arg_values(-def) $::env(CURRENT_DEF)
    set_if_unset arg_values(-log) /dev/null

    set ::env(INPUT_DEF) $arg_values(-def)

    run_openroad_script $::env(SCRIPTS_DIR)/openroad/write_verilog.tcl -indexed_log [index_file $arg_values(-log)]
    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "write verilog - openroad"
    if { [info exists flags_map(-canonical)] } {
        yosys_rewrite_verilog $filename
    }
}

proc set_layer_tracks {args} {
    puts_info "Setting Layer Tracks..."
    set options {
        {-defFile required}
        {-layer required}
        {-valuesFile required}
        {-originalFile required}
    }
    set flags {}
    parse_key_args "set_layer_tracks" args arg_values $options flags_map $flags

    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/set_layer_tracks.py -d $arg_values(-defFile) -l $arg_values(-layer) -v $arg_values(-valuesFile) -o $arg_values(-originalFile)

}

proc run_or_antenna_check {args} {
    TIMER::timer_start
    increment_index
    puts_info "Running OpenROAD Antenna Rule Checker..."
    set antenna_log [index_file $::env(signoff_logs)/antenna.log]
    run_openroad_script $::env(SCRIPTS_DIR)/openroad/antenna_check.tcl -indexed_log $antenna_log
    set ::env(ANTENNA_CHECKER_LOG) $antenna_log
    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "antenna check - openroad"
}

proc run_antenna_check {args} {
    puts_info "Running Antenna Checks..."
    if { $::env(USE_ARC_ANTENNA_CHECK) == 1 } {
        run_or_antenna_check
    } else {
        run_magic_antenna_check
    }
}

proc or_gui {args} {
    run_openroad_script -gui $::env(SCRIPTS_DIR)/openroad/gui.tcl
}

package provide openlane 0.9