#स्टेपडेफ़िनिशन

interface StepDefinition<TModel extends FlowModel = FlowModel>
  extends Partial<Omit<ActionDefinition<TModel, FlowRuntimeContext<TModel>>, 'name'>> {
  key?: string;
  isAwait?: boolean;
  use?: string;
  sort?: number;
  preset?: boolean;
  paramsRequired?: boolean;
  hideInSettings?: boolean;
  uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
}

class MyModel extends FlowModel {}

MyModel.registerFlow({
  key: 'pageSettings',
  steps: {
    step1: {
      use: 'actionName',
      title: 'First Step',
      sort: 0,
      preset: true
    },
    step2: {
      handler: async (ctx, params) => {
        // कस्टम प्रोसेसिंग लॉजिक
        return { result: 'success' };
      },
      title: 'Second Step',
      sort: 1
    }
  }
});

steps: {
  loadData: {  // key 'loadData' है
    use: 'loadDataAction'
  }
}

// पहले एक्शन रजिस्टर करें
MyModel.registerAction({
  name: 'loadDataAction',
  handler: async (ctx, params) => {
    // डेटा लोड करने का लॉजिक
  }
});

// स्टेप में इस्तेमाल करें
steps: {
  step1: {
    use: 'loadDataAction',  // रजिस्टर्ड एक्शन को रेफर करें
    title: 'Load Data'
  }
}

title: 'Load Data'
title: 'Process Information'
title: 'Save Results'

steps: {
  step1: { sort: 0 },  // सबसे पहले एग्जीक्यूट होगा
  step2: { sort: 1 },  // इसके बाद एग्जीक्यूट होगा
  step3: { sort: 2 }   // सबसे आखिर में एग्जीक्यूट होगा
}

handler: async (ctx, params) => {
  // कॉन्टेक्स्ट की जानकारी प्राप्त करें
  const { model, flowEngine } = ctx;
  
  // प्रोसेसिंग लॉजिक
  const result = await processData(params);
  
  // परिणाम वापस करें
  return { success: true, data: result };
}

// स्टैटिक डिफ़ॉल्ट पैरामीटर
defaultParams: {
  timeout: 5000,
  retries: 3,
  format: 'json'
}

// डायनामिक डिफ़ॉल्ट पैरामीटर
defaultParams: (ctx) => {
  return {
    userId: ctx.model.uid,
    timestamp: Date.now()
  }
}

// एसिंक्रोनस डिफ़ॉल्ट पैरामीटर
defaultParams: async (ctx) => {
  const config = await loadConfig();
  return {
    apiUrl: config.apiUrl,
    apiKey: config.apiKey
  }
}

uiSchema: {
  'x-component': 'Form',
  'x-component-props': {
    layout: 'vertical'
  },
  properties: {
    name: {
      type: 'string',
      title: 'Name',
      'x-component': 'Input'
    },
    age: {
      type: 'number',
      title: 'Age',
      'x-component': 'InputNumber'
    }
  }
}

beforeParamsSave: (ctx, params, previousParams) => {
  // पैरामीटर वैलिडेशन
  if (!params.name) {
    throw new Error('Name is required');
  }
  
  // पैरामीटर ट्रांसफ़ॉर्मेशन
  params.name = params.name.trim().toLowerCase();
}

afterParamsSave: (ctx, params, previousParams) => {
  // लॉग रिकॉर्ड करें
  console.log('Step params saved:', params);
  
  // दूसरे ऑपरेशन ट्रिगर करें
  ctx.model.emitter.emit('paramsChanged', params);
}

// सिंपल मोड
uiMode: 'dialog'

// कस्टम कॉन्फ़िगरेशन
uiMode: {
  type: 'dialog',
  props: {
    width: 800,
    title: 'Step Configuration'
  }
}

// डायनामिक मोड
uiMode: (ctx) => {
  return ctx.model.isMobile ? 'drawer' : 'dialog';
}

steps: {
  step1: {
    preset: true,  // क्रिएशन के समय पैरामीटर भरने होंगे
    use: 'requiredAction'
  },
  step2: {
    preset: false, // पैरामीटर बाद में भरे जा सकते हैं
    use: 'optionalAction'
  }
}

paramsRequired: true  // मॉडल जोड़ने से पहले पैरामीटर कॉन्फ़िगर करने होंगे
paramsRequired: false // पैरामीटर बाद में कॉन्फ़िगर किए जा सकते हैं

hideInSettings: true  // सेटिंग्स में छिपाएँ
hideInSettings: false // सेटिंग्स में दिखाएँ (डिफ़ॉल्ट)

isAwait: true  // हैंडलर फ़ंक्शन के पूरा होने का इंतज़ार करें (डिफ़ॉल्ट)
isAwait: false // इंतज़ार न करें, एसिंक्रोनस रूप से एग्जीक्यूट करें

class DataProcessingModel extends FlowModel {}

DataProcessingModel.registerFlow({
  key: 'dataProcessing',
  title: 'Data Processing',
  steps: {
    loadData: {
      use: 'loadDataAction',
      title: 'Load Data',
      sort: 0,
      preset: true,
      paramsRequired: true,
      defaultParams: {
        source: 'api',
        timeout: 5000
      },
      uiMode: 'dialog'
    },
    processData: {
      handler: async (ctx, params) => {
        const data = await ctx.model.getData();
        return processData(data, params);
      },
      title: 'Process Data',
      sort: 1,
      defaultParams: (ctx) => ({
        userId: ctx.model.uid,
        timestamp: Date.now()
      }),
      beforeParamsSave: (ctx, params) => {
        if (!params.processor) {
          throw new Error('Processor is required');
        }
      },
      afterParamsSave: (ctx, params) => {
        ctx.model.emitter.emit('dataProcessed', params);
      }
    },
    saveData: {
      use: 'saveDataAction',
      title: 'Save Data',
      sort: 2,
      hideInSettings: false,
      uiMode: {
        type: 'drawer',
        props: {
          width: 600,
          title: 'Save Configuration'
        }
      }
    }
  }
});