/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 * @NModuleScope SameAccount
 * @description GFS temperature range validation for item records
 */
define(['N/ui/message'], (message) => {

  const validateField = (context) => {
    const { fieldId, currentRecord } = context;

    if (fieldId === 'custitem_gfs_storage_temp') {
      const temp = currentRecord.getValue({ fieldId });
      if (temp && (temp < 33 || temp > 41)) {
        const msg = message.create({
          type: message.Type.ERROR,
          title: 'Temperature Out of Range',
          message: `Storage temp must be 33-41F. Current: ${temp}F`
        });
        msg.show({ duration: 5000 });
        return false;
      }
    }
    return true;
  };

  return { validateField };
});

/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 */
define(['N/search', 'N/currentRecord'], (search, cr) => {

  const fieldChanged = (context) => {
    const { fieldId, currentRecord } = context;

    if (fieldId === 'entity') {
      const vendorId = currentRecord.getValue({ fieldId: 'entity' });
      if (!vendorId) return;

      // Search for vendor-sourced items
      const itemSearch = search.create({
        type: 'item',
        filters: [
          ['vendor', 'anyof', vendorId],
          'AND',
          ['isinactive', 'is', 'F']
        ],
        columns: ['internalid', 'itemid', 'displayname']
      });

      const validItems = [];
      itemSearch.run().each((result) => {
        validItems.push(result.getValue('internalid'));
        return true;
      });

      // Store for line validation
      currentRecord.setValue({
        fieldId: 'custbody_gfs_valid_items',
        value: JSON.stringify(validItems)
      });
    }
  };

  return { fieldChanged };
});

/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 */
define([], () => {

  const HAZMAT_FIELDS = [
    'custitem_gfs_un_number',
    'custitem_gfs_packing_group',
    'custitem_gfs_hazard_class',
    'custitem_gfs_sds_url'
  ];

  const toggleHazmatFields = (currentRecord) => {
    const isHazmat = currentRecord.getValue({
      fieldId: 'custitem_gfs_special_handling'
    });

    HAZMAT_FIELDS.forEach(fieldId => {
      const field = currentRecord.getField({ fieldId });
      if (field) {
        field.isDisplay = !!isHazmat;
        field.isMandatory = !!isHazmat;
      }
    });
  };

  const pageInit = (context) => toggleHazmatFields(context.currentRecord);

  const fieldChanged = (context) => {
    if (context.fieldId === 'custitem_gfs_special_handling') {
      toggleHazmatFields(context.currentRecord);
    }
  };

  return { pageInit, fieldChanged };
});

/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 */
define(['N/ui/dialog'], (dialog) => {

  const saveRecord = (context) => {
    const rec = context.currentRecord;
    const errors = [];

    if (!rec.getValue('trandate'))
      errors.push('Transaction date is required');
    if (!rec.getValue('department'))
      errors.push('Brand (department) is required');
    if (!rec.getValue('location'))
      errors.push('Warehouse location is required');
    if (!rec.getValue('custbody_gfs_delivery_date'))
      errors.push('Expected delivery date is required');
    if (rec.getLineCount({ sublistId: 'item' }) === 0)
      errors.push('At least one line item is required');

    if (errors.length > 0) {
      dialog.alert({
        title: 'GFS Validation',
        message: errors.join('\n')
      });
      return false;
    }
    return true;
  };

  return { saveRecord };
});

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 * @NModuleScope SameAccount
 */
define(['N/runtime', 'N/record'], (runtime, record) => {

  const beforeLoad = (context) => {
    if (context.type !== context.UserEventType.CREATE) return;

    const { newRecord, form } = context;
    const role = runtime.getCurrentUser().role;

    // Set warehouse default based on customer region
    const custId = newRecord.getValue('entity');
    if (custId) {
      const custRec = record.load({ type: 'customer', id: custId });
      const state = custRec.getValue('shipstate');
      const warehouse = getWarehouseByState(state);
      newRecord.setValue({ fieldId: 'location', value: warehouse });
    }

    // Hide internal fields from non-admin roles
    if (role !== 3) { // 3 = Administrator
      ['custbody_gfs_internal_notes', 'custbody_gfs_margin_pct']
        .forEach(id => {
          const field = form.getField({ id });
          if (field) field.updateDisplayType({
            displayType: 'hidden'
          });
        });
    }
  };

  const getWarehouseByState = (state) => {
    const eastStates = ['NY','NJ','CT','PA','MA','ME','NH','VT','RI','DE','MD'];
    // Edgewood = 1, Hermitage = 2
    return eastStates.includes(state) ? 1 : 2;
  };

  return { beforeLoad };
});

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 */
define(['N/error'], (error) => {

  const BIG_9 = [
    'milk', 'eggs', 'fish', 'shellfish', 'tree_nuts',
    'peanuts', 'wheat', 'soybeans', 'sesame'
  ];

  const beforeSubmit = (context) => {
    if (context.type === context.UserEventType.DELETE) return;

    const rec = context.newRecord;
    const hasAllergen = BIG_9.some(a =>
      rec.getValue({ fieldId: `custitem_gfs_allergen_${a}` })
    );

    if (hasAllergen) {
      const statement = rec.getValue('custitem_gfs_allergen_statement');
      if (!statement) {
        throw error.create({
          name: 'GFS_ALLERGEN_REQUIRED',
          message: 'Allergen contains statement is required when ' +
            'any Big 9 allergen is flagged. Update the allergen ' +
            'statement field before saving.',
          notifyOff: false
        });
      }

      // Auto-generate allergen summary for labels
      const active = BIG_9.filter(a =>
        rec.getValue({ fieldId: `custitem_gfs_allergen_${a}` })
      );
      rec.setValue({
        fieldId: 'custitem_gfs_allergen_summary',
        value: `Contains: ${active.join(', ').toUpperCase()}`
      });
    }
  };

  return { beforeSubmit };
});

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 */
define(['N/record', 'N/email', 'N/render', 'N/runtime', 'N/log'],
  (record, email, render, runtime, log) => {

  const afterSubmit = (context) => {
    if (context.type !== context.UserEventType.EDIT) return;

    const rec = record.load({
      type: context.newRecord.type,
      id: context.newRecord.id
    });
    const status = rec.getValue('orderstatus');

    // Only fire on transition to Approved (B)
    if (status !== 'B') return;
    const oldStatus = context.oldRecord.getValue('orderstatus');
    if (oldStatus === 'B') return;

    // 1. Send order confirmation email
    const custId = rec.getValue('entity');
    const template = render.mergeEmail({
      templateId: 'custtemplate_gfs_order_confirm',
      entity: { type: 'customer', id: custId },
      transactionId: rec.id
    });
    email.send({
      author: runtime.getCurrentUser().id,
      recipients: custId,
      subject: template.subject,
      body: template.body
    });

    // 2. Create warehouse task
    const task = record.create({ type: 'task' });
    task.setValue({ fieldId: 'title',
      value: `Pick/Pack SO#${rec.getValue('tranid')}` });
    task.setValue({ fieldId: 'assigned',
      value: getWarehouseLead(rec.getValue('location')) });
    task.setValue({ fieldId: 'transaction', value: rec.id });
    task.save();

    // 3. Audit log
    log.audit({
      title: '[GFS] Sales | Order Approved',
      details: `SO ${rec.getValue('tranid')} approved by ` +
        `${runtime.getCurrentUser().name}`
    });
  };

  const getWarehouseLead = (locationId) => {
    // Edgewood warehouse lead = 142, Hermitage = 156
    return locationId === 1 ? 142 : 156;
  };

  return { afterSubmit };
});

/**
 * @NApiVersion 2.1
 * @NScriptType Suitelet
 */
define(['N/ui/serverWidget', 'N/record', 'N/redirect'],
  (ui, record, redirect) => {

  const onRequest = (context) => {
    if (context.request.method === 'GET') {
      const form = ui.createForm({
        title: 'GFS Vendor Onboarding',
        hideNavBar: false
      });

      // GFS branded header via inline HTML
      form.addField({
        id: 'custpage_header', type: 'inlinehtml', label: ' '
      }).defaultValue = `
        <div style="background:#092F64;color:#fff;padding:16px 24px;
          margin:-10px -10px 20px;font-family:Inter,sans-serif;">
          <div style="font-size:9px;letter-spacing:.12em;
            text-transform:uppercase;opacity:.7;">
            Global Food Solutions, Inc.</div>
          <div style="font-size:20px;font-weight:700;margin-top:4px;">
            New Vendor Registration</div>
        </div>`;

      // Company info group
      const grp1 = form.addFieldGroup({
        id: 'grp_company', label: 'Company Information'
      });
      form.addField({
        id: 'custpage_company', type: 'text',
        label: 'Company Name', container: 'grp_company'
      }).isMandatory = true;
      form.addField({
        id: 'custpage_ein', type: 'text',
        label: 'EIN / Tax ID', container: 'grp_company'
      });

      // Certifications group
      const grp2 = form.addFieldGroup({
        id: 'grp_certs', label: 'Certifications'
      });
      ['USDA', 'FDA', 'SQF', 'Organic', 'Kosher'].forEach(cert => {
        form.addField({
          id: `custpage_cert_${cert.toLowerCase()}`,
          type: 'checkbox',
          label: cert, container: 'grp_certs'
        });
      });

      form.addSubmitButton({ label: 'Submit Application' });
      context.response.writePage(form);

    } else {
      // POST: create vendor record
      const params = context.request.parameters;
      const vendor = record.create({ type: 'vendor' });
      vendor.setValue({
        fieldId: 'companyname',
        value: params.custpage_company
      });
      vendor.setValue({
        fieldId: 'custentity_gfs_ein',
        value: params.custpage_ein
      });
      const vendorId = vendor.save();

      redirect.toRecord({
        type: 'vendor', id: vendorId
      });
    }
  };

  return { onRequest };
});

/**
 * @NApiVersion 2.1
 * @NScriptType Suitelet
 */
define(['N/ui/serverWidget', 'N/search'], (ui, search) => {

  const onRequest = (context) => {
    const form = ui.createForm({ title: 'GFS Open Purchase Orders' });
    const list = form.addSublist({
      id: 'custpage_po_list',
      type: ui.SublistType.LIST,
      label: 'Open POs'
    });

    list.addField({ id: 'po_num', type: 'text', label: 'PO #' });
    list.addField({ id: 'vendor', type: 'text', label: 'Vendor' });
    list.addField({ id: 'amount', type: 'currency', label: 'Amount' });
    list.addField({ id: 'status', type: 'text', label: 'Status' });
    list.addField({ id: 'expected', type: 'date', label: 'Expected' });

    const poSearch = search.create({
      type: 'purchaseorder',
      filters: [['mainline', 'is', 'T'], 'AND',
                ['status', 'anyof', 'PurchOrd:A', 'PurchOrd:B']],
      columns: ['tranid', 'entity', 'total', 'statusref',
                 'custbody_gfs_delivery_date']
    });

    let line = 0;
    poSearch.run().each((result) => {
      list.setSublistValue({ id: 'po_num', line, value: result.getValue('tranid') });
      list.setSublistValue({ id: 'vendor', line, value: result.getText('entity') });
      list.setSublistValue({ id: 'amount', line, value: result.getValue('total') });
      list.setSublistValue({ id: 'status', line, value: result.getText('statusref') });
      list.setSublistValue({ id: 'expected', line,
        value: result.getValue('custbody_gfs_delivery_date') || '' });
      line++;
      return line < 500;
    });

    context.response.writePage(form);
  };

  return { onRequest };
});

/**
 * @NApiVersion 2.1
 * @NScriptType Restlet
 * @NModuleScope SameAccount
 * @description GFS Item API - CRUD operations with TBA auth
 */
define(['N/record', 'N/search', 'N/log', 'N/error', 'N/runtime'],
  (record, search, log, error, runtime) => {

  // ── Helpers ──
  const response = (status, data) =>
    JSON.stringify({ status, timestamp: new Date().toISOString(), data });

  const errorResponse = (code, message) =>
    response('error', { code, message });

  const logRequest = (method, detail) =>
    log.audit({
      title: `[GFS] RESTlet | ${method}`,
      details: `User: ${runtime.getCurrentUser().name} | ${detail}`
    });

  // ── GET: Record lookup ──
  const get = (params) => {
    logRequest('GET', `Item ID: ${params.id}`);

    if (!params.id) return errorResponse('MISSING_ID', 'Item ID required');

    try {
      const item = record.load({
        type: 'inventoryitem', id: params.id
      });
      return response('ok', {
        id: item.id,
        sku: item.getValue('itemid'),
        name: item.getValue('displayname'),
        upc: item.getValue('upccode'),
        price: item.getValue('baseprice'),
        onHand: item.getValue('quantityonhand'),
        allergens: item.getValue('custitem_gfs_allergen_summary')
      });
    } catch (e) {
      return errorResponse('NOT_FOUND', `Item ${params.id} not found`);
    }
  };

  // ── POST: Record create ──
  const post = (body) => {
    logRequest('POST', `Creating item: ${body.sku}`);

    if (!body.sku || !body.name)
      return errorResponse('VALIDATION', 'sku and name are required');

    try {
      const item = record.create({ type: 'inventoryitem' });
      item.setValue({ fieldId: 'itemid', value: body.sku });
      item.setValue({ fieldId: 'displayname', value: body.name });
      if (body.upc) item.setValue({ fieldId: 'upccode', value: body.upc });
      if (body.price) item.setValue({ fieldId: 'baseprice', value: body.price });
      const id = item.save();

      return response('created', { id, sku: body.sku });
    } catch (e) {
      return errorResponse('CREATE_FAILED', e.message);
    }
  };

  // ── PUT: Record update ──
  const put = (body) => {
    logRequest('PUT', `Updating item: ${body.id}`);

    if (!body.id) return errorResponse('MISSING_ID', 'Item ID required');

    try {
      const fields = {};
      if (body.name) fields.displayname = body.name;
      if (body.price) fields.baseprice = body.price;
      if (body.upc) fields.upccode = body.upc;

      record.submitFields({
        type: 'inventoryitem',
        id: body.id,
        values: fields
      });
      return response('updated', { id: body.id });
    } catch (e) {
      return errorResponse('UPDATE_FAILED', e.message);
    }
  };

  // ── DELETE: Record deactivate (never hard delete) ──
  const doDelete = (params) => {
    logRequest('DELETE', `Deactivating item: ${params.id}`);

    if (!params.id) return errorResponse('MISSING_ID', 'Item ID required');

    try {
      record.submitFields({
        type: 'inventoryitem',
        id: params.id,
        values: { isinactive: true }
      });
      return response('deactivated', { id: params.id });
    } catch (e) {
      return errorResponse('DELETE_FAILED', e.message);
    }
  };

  return { get, post, put, 'delete': doDelete };
});

/**
 * @NApiVersion 2.1
 * @NScriptType ScheduledScript
 * @description GFS Daily AR Aging Email Report
 */
define(['N/search', 'N/email', 'N/render', 'N/runtime', 'N/log', 'N/task'],
  (search, email, render, runtime, log, task) => {

  const GOVERNANCE_THRESHOLD = 500;
  const FINANCE_ROLE = 1032;

  const execute = (context) => {
    const script = runtime.getCurrentScript();
    let lastProcessed = script.getParameter({
      name: 'custscript_gfs_ar_last_id'
    }) || 0;

    log.audit({
      title: '[GFS] AR Aging | Start',
      details: `Resuming from ID: ${lastProcessed}`
    });

    const agingSearch = search.create({
      type: 'invoice',
      filters: [
        ['mainline', 'is', 'T'], 'AND',
        ['status', 'anyof', 'CustInvc:A'], 'AND',
        ['internalidnumber', 'greaterthan', lastProcessed]
      ],
      columns: [
        search.createColumn({ name: 'internalid', sort: search.Sort.ASC }),
        'entity', 'tranid', 'total', 'daysoverdue'
      ]
    });

    const buckets = { current: 0, d30: 0, d60: 0, d90: 0, d90plus: 0 };
    let processedCount = 0;

    agingSearch.run().each((result) => {
      // Governance check
      if (script.getRemainingUsage() < GOVERNANCE_THRESHOLD) {
        log.audit({
          title: '[GFS] AR Aging | Checkpoint',
          details: `Saving at ID ${result.id}, processed ${processedCount}`
        });
        reschedule(result.id);
        return false;
      }

      const days = parseInt(result.getValue('daysoverdue')) || 0;
      const amount = parseFloat(result.getValue('total')) || 0;

      if (days <= 0) buckets.current += amount;
      else if (days <= 30) buckets.d30 += amount;
      else if (days <= 60) buckets.d60 += amount;
      else if (days <= 90) buckets.d90 += amount;
      else buckets.d90plus += amount;

      lastProcessed = result.id;
      processedCount++;
      return true;
    });

    // Send summary email
    if (processedCount > 0) {
      email.send({
        author: -5, // System
        recipients: FINANCE_ROLE,
        subject: `GFS AR Aging Summary - ${new Date().toLocaleDateString()}`,
        body: formatAgingEmail(buckets, processedCount)
      });
    }

    log.audit({
      title: '[GFS] AR Aging | Complete',
      details: `Processed ${processedCount} invoices`
    });
  };

  const reschedule = (lastId) => {
    const scriptTask = task.create({ taskType: task.TaskType.SCHEDULED_SCRIPT });
    scriptTask.scriptId = runtime.getCurrentScript().id;
    scriptTask.deploymentId = runtime.getCurrentScript().deploymentId;
    scriptTask.params = { custscript_gfs_ar_last_id: lastId };
    scriptTask.submit();
  };

  const formatAgingEmail = (b, count) =>
    `AR Aging Report\n` +
    `Current: $${b.current.toFixed(2)}\n` +
    `1-30 Days: $${b.d30.toFixed(2)}\n` +
    `31-60 Days: $${b.d60.toFixed(2)}\n` +
    `61-90 Days: $${b.d90.toFixed(2)}\n` +
    `90+ Days: $${b.d90plus.toFixed(2)}\n` +
    `Total Invoices: ${count}`;

  return { execute };
});

/**
 * @NApiVersion 2.1
 * @NScriptType MapReduceScript
 * @description GFS CME-based cheese pricing update (weekly)
 */
define(['N/search', 'N/record', 'N/log', 'N/email', 'N/runtime'],
  (search, record, log, email, runtime) => {

  // ── Phase 1: Get Input Data ──
  const getInputData = () => {
    return search.create({
      type: 'inventoryitem',
      filters: [
        ['custitem_gfs_cme_linked', 'is', 'T'], 'AND',
        ['isinactive', 'is', 'F']
      ],
      columns: [
        'internalid', 'itemid', 'displayname',
        'custitem_gfs_cme_basis', 'custitem_gfs_moisture_bracket',
        'baseprice'
      ]
    });
  };

  // ── Phase 2: Map (per item) ──
  const map = (context) => {
    const data = JSON.parse(context.value);
    const itemId = data.id;
    const basis = parseFloat(data.values.custitem_gfs_cme_basis) || 0;
    const bracket = data.values.custitem_gfs_moisture_bracket || 'standard';

    // CME trailing week average (from GFS config record)
    const cmePrice = getCMETrailingWeek();
    const premiumPct = bracket === 'high_moisture' ? 0.35 : 0;
    const newPrice = (cmePrice + basis) * (1 + premiumPct);

    // Emit to reduce phase grouped by price change direction
    const direction = newPrice > parseFloat(data.values.baseprice)
      ? 'increase' : 'decrease';

    context.write({
      key: direction,
      value: JSON.stringify({
        itemId, sku: data.values.itemid,
        oldPrice: data.values.baseprice,
        newPrice: newPrice.toFixed(4)
      })
    });
  };

  // ── Phase 3: Reduce (batch by direction) ──
  const reduce = (context) => {
    context.values.forEach(val => {
      const item = JSON.parse(val);
      try {
        record.submitFields({
          type: 'inventoryitem',
          id: item.itemId,
          values: { baseprice: item.newPrice }
        });
        log.audit({
          title: '[GFS] Pricing | Updated',
          details: `${item.sku}: $${item.oldPrice} -> $${item.newPrice}`
        });
      } catch (e) {
        log.error({
          title: '[GFS] Pricing | Failed',
          details: `${item.sku}: ${e.message}`
        });
      }
    });
  };

  // ── Phase 4: Summarize ──
  const summarize = (summary) => {
    let updated = 0, failed = 0;

    summary.reduceSummary.errors.iterator().each((key, error) => {
      log.error({ title: `Reduce Error [${key}]`, details: error });
      failed++;
      return true;
    });

    summary.reduceSummary.keys.iterator().each(() => {
      updated++;
      return true;
    });

    const msg = `GFS CME Pricing Update Complete\n` +
      `Updated: ${updated}\nFailed: ${failed}\n` +
      `Duration: ${summary.seconds}s\n` +
      `Governance Used: ${summary.usage}`;

    log.audit({ title: '[GFS] Pricing | Summary', details: msg });

    email.send({
      author: -5,
      recipients: runtime.getCurrentUser().id,
      subject: 'GFS CME Pricing Update Complete',
      body: msg
    });
  };

  // ── Helper ──
  const getCMETrailingWeek = () => {
    const config = search.lookupFields({
      type: 'customrecord_gfs_config',
      id: 1,
      columns: ['custrecord_gfs_cme_trailing_avg']
    });
    return parseFloat(config.custrecord_gfs_cme_trailing_avg) || 1.85;
  };

  return { getInputData, map, reduce, summarize };
});