import { ComfyWidgets } from '../../../scripts/widgets.js'


export function getDefaultOptions(type, value = 0){
    let options = {};
    switch(type){
        case "INT":
            options = {default: value, "min": 0, "max": 18446744073709551616, "step": 1};
            break;
        case "FLOAT":
            options = {default: value, "min": 0.00, "max": 2048.00, "step": 0.01};
            break;
        case "STRING":
            options = {default: value};
            break;
        default:
            options = {};
    }
    return options;
}

export function addWidgets(root_obj, field_name, value, app){
    let type = value.type;
    if (type == "converted-widget"){
        type = value.origType;
    }
    
    // S'assurer que le nœud a un objet de stockage local pour ses définitions d'entrée
    if (!root_obj.local_input_defs) {
        root_obj.local_input_defs = {
            required: {},
            optional: {}
        };
    }
    
    if ((type == "STRING" || type =="text") && field_name != "workflow"){
        ComfyWidgets.STRING(root_obj, field_name, ['STRING', getDefaultOptions("STRING", value.value),],app,)
        // Stocker la définition localement au lieu de modifier nodeData
        root_obj.local_input_defs.required[field_name] = ["STRING", getDefaultOptions("STRING", value.value)];
    }
    
    if (type == "INT" || type == "number"){
        ComfyWidgets.INT(
            root_obj,
            field_name,
            ['INT', getDefaultOptions("INT", value.value),],
            app,
        )
        // Stocker la définition localement
        root_obj.local_input_defs.required[field_name] = ["INT", getDefaultOptions("INT", value.value)];
    }
    
    if (type == "FLOAT"){
        ComfyWidgets.FLOAT(
            root_obj,
            field_name,
            ['FLOAT',getDefaultOptions("FLOAT", value.value),],
            app,
        )
        // Stocker la définition localement
        root_obj.local_input_defs.required[field_name] = ["FLOAT", getDefaultOptions("FLOAT", value.value)];
    }
    
    if (type == "BOOLEAN" || type == "toggle"){
        root_obj.addWidget("toggle",field_name, value.value, ()=>{});
        // Stocker la définition localement
        root_obj.local_input_defs.required[field_name] = ["BOOLEAN", getDefaultOptions("BOOLEAN", value.value)];
    }
    /*
    if (field_name == "workflow"){
        root_obj.addWidget("STRING", field_name, value.value, ()=>{});
        root_obj.widgets[root_obj.widgets.length - 1].hidden = true;
        // Stocker la définition localement 
        root_obj.local_input_defs.required[field_name] = ["STRING", {}];
    }*/
    if (type == "IMAGE") root_obj.addInput(field_name, "IMAGE");
    if (type == "LATENT") root_obj.addInput(field_name, "LATENT");
    if (type == "MODEL") root_obj.addInput(field_name, "MODEL");
    if (type == "CLIP") root_obj.addInput(field_name, "CLIP");
    if (type == "MASK") root_obj.addInput(field_name, "MASK");
    if (type == "CONDITIONING") root_obj.addInput(field_name, "CONDITIONING");
    if (type == "VAE") root_obj.addInput(field_name, "VAE");
}

export function hideWidget(
    node,
    widget,
    options = {}
  ) {
    const { suffix = '', holdSpace = true } = options
  
    if (widget.type?.startsWith("converted-widget")) return
    widget.origType = widget.type
    widget.origComputeSize = widget.computeSize
    widget.origSerializeValue = widget.serializeValue
    // @ts-expect-error custom widget type
    widget.type = "converted-widget" + suffix
    if (holdSpace) {
        widget.computeSize = () => [0, LiteGraph.NODE_WIDGET_HEIGHT]
        widget.serializeValue = (node, index) => {
            // Prevent serializing the widget if we have no input linked
            if (!node.inputs) {
              return undefined
            }
            let node_input = node.inputs.find((i) => i.widget?.name === widget.name)
        
            if (!node_input || !node_input.link) {
              return undefined
            }
            return widget.origSerializeValue
              ? widget.origSerializeValue(node, index)
              : widget.value
        }
    } else {
        // -4 is due to the gap litegraph adds between widgets automatically
        widget.computeSize = () => [0, -4]
        widget.serializeValue = (node, index) => {
            return widget.origSerializeValue
                ? widget.origSerializeValue(node, index)
                : widget.value
        }   
    }

    // Hide any linked widgets, e.g. seed+seedControl
    if (widget.linkedWidgets) {
      for (const w of widget.linkedWidgets) {
        hideWidget(node, w, { suffix: ':' + widget.name, holdSpace: false })
      }
    }
  }

  export function convertToInput(
    node,
    widget
  ) {
    hideWidget(node, widget)
    // Add input and store widget config for creating on primitive node
    const [oldWidth, oldHeight] = node.size

    for (const widget of node.widgets) {
      widget.last_y += LiteGraph.NODE_SLOT_HEIGHT
    }
  
    // Restore original size but grow if needed
    node.setSize([
      Math.max(oldWidth, node.size[0]),
      Math.max(oldHeight, node.size[1])
    ])
    return node
  }