import { Input, Button, Form, Card, Select, Col, DatePicker, Row, Tooltip, Tabs, Modal, Typography, Tag, Popconfirm } from 'antd';
import Table, { ColumnProps } from 'antd/lib/table';
import moment from 'moment';
import React, { useEffect, useRef, useState } from 'react';
import { BarcodeOutlined, DownloadOutlined, EditOutlined, SafetyCertificateOutlined, SearchOutlined, UndoOutlined } from '@ant-design/icons';
import Highlighter from 'react-highlight-words';
import { AntiBioticsReportService, RMGrnService } from '@gtpl/shared-services/raw-material-procurement';
import { AlertMessages } from '@gtpl/shared-utils/alert-messages';
import { useForm } from 'antd/lib/form/Form';
import { Link } from 'react-router-dom';
import { Excel } from 'antd-table-saveas-excel';
import { AllocatedLab, PassOrFail } from '@gtpl/shared-models/common-models';
import AntiBioticsMicrobiologyForms from './antibiotics-evoulation-form';
import { title } from 'process';
import { SortOrder } from 'antd/lib/table/interface';
import { AntibioticsReq } from './antibiotics-req';



const AntiBioticsView = () => {
    const [searchText, setSearchText] = useState('');
    const [searchedColumn, setSearchedColumn] = useState('');
    const searchInput = useRef(null);
      const antiMicroTInfoService = new AntiBioticsReportService();
      const [data ,setData] = useState([])
      const { Option } = Select;
      const [form ] = useForm()
      const { RangePicker } = DatePicker;
      const [isModalVisible, setIsModalVisible] = useState(false);
      const [selectedRecord, setSelectedRecord] = useState(null);
      const [indentNumber, setIndentNumber] = useState(null); // State for indent number
      const [grnNumber,setGrnNumber] = useState(null)
      const [lotNumber,setLotChange] = useState(null)
      const [refreshKey, setRefreshKey] = useState(0);
      const [allotedLab,setAllocatedLab] = useState(null)
      const [testAt,setTestAt] = useState<string | null>();
      const [wasCreating,setWasCreating] = useState(false)
      const [status,setStatusLab] = useState(null)
      const [activeTab, setActiveTab] = React.useState("1");
      // const [completedPage, setCompletedPage] = useState(1);
      // const [pendingPage, setPendingPage] = useState(1);
      // const [processingPage,setProcessingPage] = useState(1);
      const [formType, setFormType] = useState(null);
      const [harvestdata,setHarvestData] = useState()
      const [gradingData,setGradingData] = useState()
      const [dateRange, setDateRange] = useState([null, null]); 
      const [selectedTest, setSelectedTest] = useState<string | null>("PRE HARVEST");
      const [pendingData, setPendingData] = useState<any[]>([]);
      const [harvestSecondaryData, setHarvestSecondaryData] = useState<any[]>([]);
      const [gradingSecondaryData, setGradingSecondaryData] = useState<any[]>([]);
      const [page, setPage] = React.useState(1); 
      const { TabPane } = Tabs;
      const { Text } = Typography;
      const rMGrnService = new RMGrnService()
      const antiBioticsReportService = new AntiBioticsReportService()
      useEffect(() => {
        getPreHarvestData();
      }, []);

      // useEffect(() => {
      //   getAllAntiBioticsResult(null, null, null,null,null,null,null,null); // Call with default values
      // }, [selectedRecord]);

      const handleFormTypeChange = (value: string) => {
        form.resetFields(); // Reset all form fields
        setSearchText(""); 
        setSearchedColumn(""); 
        setTestAt(value);
        setSelectedTest(value);
        setPage(1)
        // Fetch new data based on selected test type
        // if (value === "PRE HARVEST") {
        //   getPreHarvestData();
        // } else if (value === "GRADING") {
        //   getGradingData();
        // }
      };
      

      useEffect(() => {
        if (selectedTest === "PRE HARVEST") {
          getPreHarvestData( );
        } 
        else if (selectedTest === "GRADING") {
          getGradingData();
        }
      }, [selectedTest, refreshKey]);

      const handleIndentChange = (value: any) => {
        setIndentNumber(value); 
      };

      const handlegrnChange =(value: any)=>{
        setGrnNumber(value)
      }

      const handleLotChange =(value: any)=>{
        setLotChange(value)
      }
      const handleAllcatedLabChange =(value: any)=>{
        setAllocatedLab(value)
      }
      const handleAllTestAtChange =(value: any)=>{
        setTestAt(value)
      }
      const handleStatusChange =(value: any)=>{
        setStatusLab(value)
      }

      const handleEdit = (record) => {
        setSelectedRecord(record);
        setWasCreating(false)
        setIsModalVisible(true);
      };

      const handleTabChange = (key) => {
        setActiveTab(key);
        setPage(1); 
      };

      const handleCreate = (record) => {
        setSelectedRecord(record);
        setWasCreating(true)
        setIsModalVisible(true)
      }
    
      const handleCancel = () => {
        setIsModalVisible(false);
        form.resetFields()
        setSelectedRecord(null);
      };
      
      // const handleDateRangeChange = (dates, dateStrings) => {
      //   const [fromDate, toDate] = dates ? dateStrings : [null, null];
      //   getAllAntiBioticsResult(fromDate, toDate, indentNumber); // Include indent number in the request
      // };
      const handleDateRangeChange = (dates: any, dateStrings: [any, any]) => {
        const [fromDate, toDate] = dates ? dateStrings : [null, null];
        setDateRange([fromDate, toDate]); // Store the selected date range in the state
      };
      

      // const getAllAntiBioticsResult = (fromDate: null, toDate: null, indentNumber: null,grnNumber: null,lotNumber: null,allotedLab: null,status: null,testAt: null) => {
      //   antiMicroTInfoService
      //     .getAllAntiBioticsResult({ fromDate, toDate, indentNumber,grnNumber,lotNumber,allotedLab,status,testAt })
      //     .then((res) => {
      //       if (res.status) {
      //         setData(res.data);
      //       } else {
      //         AlertMessages.getErrorMessage(res.internalMessage);
      //         setData([]);
      //       }
      //     })
      //     .catch((err) => {
      //       AlertMessages.getErrorMessage(err.message);
      //       setData([]);
      //     });
      // };

      // const getPreHarvestData = (fromDate: null, toDate: null, indentNumber: null,grnNumber: null,lotNumber: null,allotedLab: null,status: null,testAt: null) => {
      //   rMGrnService.getRmGrnfullDataForHarvest({ fromDate, toDate, indentNumber,grnNumber,lotNumber,allotedLab,status,testAt })
      //   .then((res) => {
      //     if(res.status) {
      //       setPendingData(res.data)
      //       antiBioticsReportService.getAllAntiBioticsPreHarvestData({fromDate, toDate, indentNumber,grnNumber,lotNumber,allotedLab,status,testAt})
      //       .then((res) => {
      //         if(res.status) {
      //           setHarvestSecondaryData(res.data)
      //         }
      //       })
      //     } else {
      //       AlertMessages.getErrorMessage(res.internalMessage);
      //       setData([]);
      //     }
      //   })
      //   .catch((err) => {
      //     AlertMessages.getErrorMessage(err.message);
      //     setData([]);
      //   });
      // }

      const getPreHarvestData = () => {
        const req = new AntibioticsReq()
        if (form.getFieldValue('grnDate') !== undefined) {
          req.fromDate = (form.getFieldValue('grnDate')[0]).format('YYYY-MM-DD');
        }
        if (form.getFieldValue('grnDate') !== undefined) {
          req.toDate = (form.getFieldValue('grnDate')[1]).format('YYYY-MM-DD');
        }
        rMGrnService.getRmGrnfullDataForHarvest(req)
        .then((res) => {
          if(res.status) {
            setPendingData(res.data)
            antiBioticsReportService.getAllAntiBioticsPreHarvestData(req)
            .then((res) => {
              if(res.status) {
                setHarvestSecondaryData(res.data)
              }
            })
          } else {
            AlertMessages.getErrorMessage(res.internalMessage);
            setData([]);
          }
        })
        .catch((err) => {
          AlertMessages.getErrorMessage(err.message);
          setData([]);
        });
      }
      
      const getGradingData = () => {
        const req = new AntibioticsReq()
        if (form.getFieldValue('grnDate') !== undefined) {
          req.fromDate = (form.getFieldValue('grnDate')[0]).format('YYYY-MM-DD');
        }
        if (form.getFieldValue('grnDate') !== undefined) {
          req.toDate = (form.getFieldValue('grnDate')[1]).format('YYYY-MM-DD');
        }

        rMGrnService.getRmGrmFullDataForGrading(req)
        
        .then((res) => {
          if(res.status) {
            setPendingData(res.data)
            antiBioticsReportService.getAllAntiBioticsGradingData(req)
            .then((res) => {
              if(res.status) {
                setGradingSecondaryData(res.data)
              }
            })
          } else {
            AlertMessages.getErrorMessage(res.internalMessage);
            setData([]);
          }
        })
        .catch((err) => {
          AlertMessages.getErrorMessage(err.message);
          setData([]);
        });
      }

      const handleSearch1 = () => {
        const [fromDate, toDate] = dateRange; // Retrieve the date range from the state
        //getAllAntiBioticsResult(fromDate, toDate, indentNumber,grnNumber,lotNumber,allotedLab,status,testAt); // Fetch filtered data
        // if(selectedTest === 'GRADING') {
        //   getGradingData( null, null, indentNumber,grnNumber,lotNumber,allotedLab,status,null );
        // } 
        // if(selectedTest ==='PRE HARVESTING') {
        //   getPreHarvestData( null, null, indentNumber,grnNumber,lotNumber,allotedLab,status,null );
        // }
      };
    
      // Handle reset button click
      // const handleReset1 = () => {
      //   form.resetFields(); // Reset form fields
      //   setDateRange([null, null]); // Clear date range state
      //   setIndentNumber(null); // Clear indent number state
      //   getAllAntiBioticsResult(null, null, null,null,null,null,null,null); 
      //   // Reset table data
      // };

      const handleReset1 = () => {
        form.resetFields(); // Reset form fields
        setDateRange([null, null]); // Clear date range state
        setIndentNumber(null); // Clear indent number state
        setGrnNumber(null); // Clear GRN number state
        setLotChange(null); // Clear lot number state
        setAllocatedLab(null); // Clear allocated lab state
        setStatusLab(null); // Clear status state
        setTestAt(null); // Clear test at state
        
        //getAllAntiBioticsResult(null, null, null, null, null, null, null, null); // Reset table data
      };
      
      const handleRevert = async (record) => {
        try {
            const response = await antiBioticsReportService.revertAntiBioticsTestStatus({
                grnItemId: record.grnItemId,
                qcAt: selectedTest,
                lotNumber: record.lotNumber || null,
            });
            if (response.status) {
                AlertMessages.getSuccessMessage(" Reverted to PROCESSING successfully.");
                setRefreshKey(prev => prev + 1); 
            } else {
                AlertMessages.getErrorMessage(response.internalMessage);
            }
        } catch (err) {
            AlertMessages.getErrorMessage(err.message);
        }
    };
  

    function handleSearch(selectedKeys: React.SetStateAction<string>[], confirm: () => void, dataIndex: React.SetStateAction<string>) {
        confirm();
        setSearchText(selectedKeys[0]);
        setSearchedColumn(dataIndex);
      };
    
      function handleReset(clearFilters: () => void) {
        clearFilters();
        setSearchText('');
        setSearchedColumn('')
      };
      

    const getColumnSearchProps = (dataIndex: string) => ({
        filterDropdown: ({ setSelectedKeys, selectedKeys, confirm, clearFilters }) => (
          <div style={{ padding: 8 }}>
            <Input
              ref={searchInput}
              placeholder={`Search ${dataIndex}`}
              value={selectedKeys[0]}
              onChange={e => setSelectedKeys(e.target.value ? [e.target.value] : [])}
              onPressEnter={() => handleSearch(selectedKeys, confirm, dataIndex)}
              style={{ width: 188, marginBottom: 8, display: 'block' }}
            />
            <Button
              type="primary"
              onClick={() => handleSearch(selectedKeys, confirm, dataIndex)}
              icon={<SearchOutlined />}
              size="small"
              style={{ width: 90, marginRight: 8 }}
            >
              Search
            </Button>
            <Button onClick={() => handleReset(clearFilters)} size="small" style={{ width: 90 }}>
              Reset
            </Button>
          </div>
        ),
        filterIcon: (filtered: any) => (
          <SearchOutlined type="search" style={{ color: filtered ? '#1890ff' : undefined }} />
        ),
        onFilter: (value: string, record: { [x: string]: { toString: () => string; }; }) =>
          record[dataIndex]
            ? record[dataIndex]
              .toString()
              .toLowerCase()
              .includes(value.toLowerCase())
            : false,
        onFilterDropdownVisibleChange: (visible: any) => {
          if (visible) { setTimeout(() => searchInput.current.select()); }
        },
        render: (text: { toString: () => any; }) =>
          text ? (
            searchedColumn === dataIndex ? (
              <Highlighter
                highlightStyle={{ backgroundColor: '#ffc069', padding: 0 }}
                searchWords={[searchText]}
                autoEscape
                textToHighlight={text.toString()}
              />
            ) : text
          ) : null
      });

      const exportExcel = () => {
        let exportData: any[] = [];
      
        if (selectedTest === "PRE HARVEST") {
          exportData = [...pendingData, ...harvestSecondaryData];
        } else if (selectedTest === "GRADING") {
          exportData = [...pendingData, ...gradingSecondaryData];
        }
      
        const formattedData = exportData.map((item) => {
          const newItem = {};
          Exceldata.forEach(({ dataIndex }) => {
            let value = item[dataIndex];

            if (dataIndex === "name") {
              value = item.supplierType === "Dealer" 
                ? (item.dealerName || "-") 
                : (item.farmerName || "-");
            }
            else if (dataIndex === "grnDate" || dataIndex === "indentDate") {
              value = value ? moment(value).format("DD-MM-YYYY") : "-";
            }
            else {
              value = value && value !== "" ? value : "-";
            }
      
            newItem[dataIndex] = value;
          });
          return newItem;
        });
      
        const excel = new Excel();
        const sheet = excel.addSheet("StockReport");
      
        sheet.addColumns(
          Exceldata.map((col) => ({
            ...col,
            align: "center",
          }))
        );
      
        sheet.addDataSource(formattedData, { str2num: true });
      
        excel.saveAs(`${selectedTest.toLowerCase()}-report.xlsx`);
      };

      const Exceldata = [
        ...(selectedTest === "PRE HARVEST"
          ? [{ title: "Indent Number", dataIndex: "indentNumber" }]
          : []),
        { title: "GRN Number", dataIndex: "grnNumber" },
        { title: "GRN Date", dataIndex: "grnDate" },
        ...(selectedTest === "GRADING"
          ? [{ title: "LOT NUMBER", dataIndex: "lotNumber" }]
          : []),
        { title: "Supplier Type", dataIndex: "supplierType" },
        { title: "Supplier Name", dataIndex: "name" }, 
        { title: "Count", dataIndex: "count" },
        { title: "Boxes", dataIndex: "boxes" },
        { title: "Indent Quantity", dataIndex: "indentQuantity" },
        { title: "GRN Quantity", dataIndex: "grnQuantity" },
        ...(selectedTest === "GRADING"
          ? [{ title: "HON Quantity", dataIndex: "HONQuantity" }]
          : []),
        { title: "CAP", dataIndex: "cap" },
        { title: "CAP Value", dataIndex: "capValue" },
        { title: "AOZ", dataIndex: "aoz" },
        { title: "AOZ Value", dataIndex: "aozValue" },
        { title: "AMOZ", dataIndex: "amoz" },
        { title: "AMOZ Value", dataIndex: "amozValue" },
        { title: "AHD", dataIndex: "ahd" },
        { title: "AHD Value", dataIndex: "ahdValue" },
        { title: "SEM", dataIndex: "sem" },
        { title: "SEM Value", dataIndex: "semValue" },
        { title: "location", dataIndex: "location" },
        { title: "Sampler Name", dataIndex: "samplerName" },
        { title: "Test At", dataIndex: "testAt" },
        { title: "Alloted Lab", dataIndex: "allotedLab" },
        { title: "Remarks", dataIndex: "remarks" },
        { title: "Result", dataIndex: "Result" },
      ];

      const gradingPendingColumn: ColumnProps<any>[] =  [
        {
          title: "S No",
          key: "id",
          responsive: ["md"],
          align: "left",
          render: (text, object, index) => (page - 1) * 10 + (index + 1),
        },

              {
                title: "GRN Number",
                key: "grnNumber",
                dataIndex: "grnNumber",
                ...getColumnSearchProps("grnNumber"),
                sorter: (a, b) => a.grnNumber?.localeCompare(b.grnNumber),
                render: (value, record) => (record.grnNumber ? record.grnNumber : "-"),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
              {
                title: "GRN Date",
                key: "grnDate",
                dataIndex: "grnDate",
                // ...getColumnSearchProps("grnDate"),
                sorter: (a, b) => a.grnDate?.localeCompare(b.grnDate),
                render:(text,record) => {
                  return(
                    <>
                    {record.grnDate ? moment(record.grnDate).format('DD-MM-YYYY') : '-'}
                    </>
                  )
                }
              },

          {
            title: "Lot Number",
            key: "lotNumber",
            dataIndex: "lotNumber",
            ...getColumnSearchProps("lotNumber"),
            sorter: (a, b) => a.lotNumber?.localeCompare(b.lotNumber),
            render: (value, record) => (record.lotNumber ? record.lotNumber : "-"),
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          {
            title: "Supplier Type",
            key: "supplierType",
            dataIndex: "supplierType",
            ...getColumnSearchProps("supplierType"),
            sorter: (a, b) => a.supplierType?.localeCompare(b.supplierType),
            render: (value, record) => (record.supplierType ? record.supplierType : "-"),
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          {
            title: " Supplier Name",
            key: "farmerName",
            dataIndex: "farmerName",
            ...getColumnSearchProps("farmerName"),
            sorter: (a, b) => {
              const nameA = (a.supplierType === "Dealer" ? a.dealerName : a.farmerName) || "";
              const nameB = (b.supplierType === "Dealer" ? b.dealerName : b.farmerName) || "";
              return nameA.localeCompare(nameB);
            },
            render: (value, record) => {
              if (record.supplierType === "Dealer") {
                return record.dealerName ? record.dealerName : "-";
              }
              return record.farmerName ? record.farmerName : "-";
            },
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
        
        {
          title: "Count",
          key: "count",
          dataIndex: "count",
          render: (value, record) => (record.count ? record.count : "-"),
          sorter: (a, b) => a.count - b.count,
          ...getColumnSearchProps("count"),
        },
        {
          title: "Boxes",
          key: "boxes",
          dataIndex: "boxes",
          render: (value, record) => (record.boxes ? record.boxes : "-"),
          sorter: (a, b) => a.boxes - b.boxes,
          ...getColumnSearchProps("boxes"),
        },
        {
          title: "Indent Quantity",
          key: "indentQuantity",
          dataIndex: "indentQuantity",
          render: (value, record) => {
            const quantity = parseFloat(record.indentQuantity);
            return isNaN(quantity) ? "-" : quantity.toFixed(2);
          },
          sorter: (a, b) => a.indentQuantity - b.indentQuantity,
          ...getColumnSearchProps("indentQuantity"),
        },
        {
          title: "GRN Quantity",
          key: "grnQuantity",
          dataIndex: "grnQuantity",
          render: (value, record) => {
            const quantity = parseFloat(record.grnQuantity);
            return isNaN(quantity) ? "-" : quantity.toFixed(2);
          },
          sorter: (a, b) => a.grnQuantity - b.grnQuantity,
          ...getColumnSearchProps("grnQuantity"),
        },
        {
          title: "Reweighment Quantity",
          key: "HONQuantity",
          dataIndex: "HONQuantity",
          render: (value, record) => {
            const quantity = parseFloat(record.HONQuantity);
            return isNaN(quantity) ? "-" : quantity.toFixed(2);
          },
          sorter: (a, b) => a.HONQuantity - b.HONQuantity,
          ...getColumnSearchProps("HONQuantity"),
        },
        {
          title: "Action",
          key: "action",
          render: (_, record) =>
            record.antibioticsTestStatus === "PENDING" ? (
              <SafetyCertificateOutlined
                onClick={() => handleCreate(record)}
                style={{ color: "red", cursor: "pointer" }}
              />
            ) : null,
        }
      ]

      const harvestPendingColumn: ColumnProps<any>[] =  [
        {
          title: "S No",
          key: "id",
          responsive: ["md"],
          align: "left",
          render: (text, object, index) => (page - 1) * 10 + (index + 1),
        },
              {
                title: "Indent Number",
                key: "indentNumber",
                dataIndex: "indentNumber",
                ...getColumnSearchProps("indentNumber"),
                sorter: (a, b) => a.indentNumber?.localeCompare(b.indentNumber),
                render: (value, record) => (record.indentNumber ? record.indentNumber : "-"),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
              // {
              //   title: "Indent Date",
              //   key: "indentDate",
              //   dataIndex: "indentDate",
              //   // ...getColumnSearchProps("indentDate"),
              //   width:'120',
              //   sorter: (a, b) => a.indentDate?.localeCompare(b.indentDate),
              //   render: (text, record) => {
              //     return (
              //       <>
              //         {record.indentDate ? moment(record.indentDate).format('DD-MM-YYYY') : '-'}
              //       </>
              //     );
              //   },
              // },
              {
                title: "GRN Number",
                key: "grnNumber",
                dataIndex: "grnNumber",
                ...getColumnSearchProps("grnNumber"),
                sorter: (a, b) => a.grnNumber?.localeCompare(b.grnNumber),
                render: (value, record) => (record.grnNumber ? record.grnNumber : "-"),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
              {
                title: "GRN Date",
                key: "grnDate",
                dataIndex: "grnDate",
                // ...getColumnSearchProps("grnDate"),
                sorter: (a, b) => a.grnDate?.localeCompare(b.grnDate),
                render:(text,record) => {
                  return(
                    <>
                    {record.grnDate ? moment(record.grnDate).format('DD-MM-YYYY') : '-'}
                    </>
                  )
                }
              },
              {
                title: "Supplier Type",
                key: "supplierType",
                dataIndex: "supplierType",
                ...getColumnSearchProps("supplierType"),
                sorter: (a, b) => a.supplierType?.localeCompare(b.supplierType),
                render: (value, record) => (record.supplierType ? record.supplierType : "-"),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
              {
                title: "Supplier Name",
                key: "farmerName",
                dataIndex: "farmerName",
                ...getColumnSearchProps("farmerName"),
                sorter: (a, b) => {
                  const nameA = (a.supplierType === "Dealer" ? a.dealerName : a.farmerName) || "";
                  const nameB = (b.supplierType === "Dealer" ? b.dealerName : b.farmerName) || "";
                  return nameA.localeCompare(nameB);
                },
                render: (value, record) => {
                  if (record.supplierType === "Dealer") {
                    return record.dealerName ? record.dealerName : "-";
                  }
                  return record.farmerName ? record.farmerName : "-";
                },
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
        
        {
          title: "Count",
          key: "count",
          dataIndex: "count",
          render: (value, record) => (record.count ? record.count : "-"),
          sorter: (a, b) => a.count - b.count,
          ...getColumnSearchProps("count"),
        },
        {
          title: "Boxes",
          key: "boxes",
          dataIndex: "boxes",
          render: (value, record) => (record.boxes ? record.boxes : "-"),
          sorter: (a, b) => a.boxes - b.boxes,
          ...getColumnSearchProps("boxes"),
        },
        {
          title: "Indent Quantity",
          key: "indentQuantity",
          dataIndex: "indentQuantity",
          render: (value, record) => {
            const quantity = parseFloat(record.indentQuantity);
            return isNaN(quantity) ? "-" : quantity.toFixed(2);
          },
          sorter: (a, b) => a.indentQuantity - b.indentQuantity,
          ...getColumnSearchProps("indentQuantity"),
        },
        {
          title: "GRN Quantity",
          key: "grnQuantity",
          dataIndex: "grnQuantity",
          render: (value, record) => {
            const quantity = parseFloat(record.grnQuantity);
            return isNaN(quantity) ? "-" : quantity.toFixed(2);
          },
          sorter: (a, b) => a.grnQuantity - b.grnQuantity,
          ...getColumnSearchProps("grnQuantity"),
        },
        {
          title: "Action",
          key: "action",
          render: (_, record) =>
            record.antibioticsTestStatus === "PENDING" ? (
              <SafetyCertificateOutlined
                onClick={() => handleCreate(record)}
                style={{ color: "red", cursor: "pointer" }}
              />
            ) : null,
        }
      ]

      const processingColumn: ColumnProps<any>[] = [
        {
          title: "S No",
          key: "id",
          responsive: ["md"],
          align: "left",
          render: (text, object, index) => (page - 1) * 10 + (index + 1),
        },
      
        ...(selectedTest === "PRE HARVEST"
          ? [
              {
                title: "Indent Number",
                key: "indentNumber",
                dataIndex: "indentNumber",
                ...getColumnSearchProps("indentNumber"),
                render: (value, record) => record.indentNumber ?record.indentNumber :  "-",
                sorter: (a, b) => a.indentNumber?.localeCompare(b.indentNumber),
                sortDirections: ["descend", "ascend"] as SortOrder[],

              },
              // {
              //   title: "Indent Date",
              //   key: "indentDate",
              //   dataIndex: "indentDate",
              //   // ...getColumnSearchProps("indentDate"),
              //   width:'120',
              //   sorter: (a, b) => a.indentDate?.localeCompare(b.indentDate),
              //   render: (text, record) => {
              //     return (
              //       <>
              //         {record.indentDate ? moment(record.indentDate).format('DD-MM-YYYY') : '-'}
              //       </>
              //     );
              //   },
              // },
            ]
          : []),
          {
            title: "GRN Number",
            key: "grnNumber",
            dataIndex: "grnNumber",
            ...getColumnSearchProps("grnNumber"),
            render: (value, record) => record.grnNumber ?record.grnNumber :  "-",
            sorter: (a, b) => a.grnNumber?.localeCompare(b.grnNumber),
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          {
            title: "GRN Date",
            key: "grnDate",
            dataIndex: "grnDate",
            // ...getColumnSearchProps("grnDate"),
            sorter: (a, b) => a.grnDate?.localeCompare(b.grnDate),
            render:(text,record) => {
              return(
                <>
                {record.grnDate ? moment(record.grnDate).format('DD-MM-YYYY') : '-'}
                </>
              )
            }
          },
      
        ...(selectedTest === "GRADING"
          ? [
           
              {
                title: "Lot Number",
                key: "lotNumber",
                dataIndex: "lotNumber",
                ...getColumnSearchProps("lotNumber"),
                render: (value, record) => (record.lotNumber ? record.lotNumber : "-"),
                sorter: (a, b) => a.lotNumber?.localeCompare(b.lotNumber),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
            ]
          : []),
          {
            title: "Supplier Type",
            key: "supplierType",
            dataIndex: "supplierType",
            ...getColumnSearchProps("supplierType"),
            sorter: (a, b) => a.supplierType?.localeCompare(b.supplierType),
            render: (value, record) => (record.supplierType ? record.supplierType : "-"),
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          {
            title: "Supplier Name",
            key: "farmerName",
            dataIndex: "farmerName",
            ...getColumnSearchProps("farmerName"),
            sorter: (a, b) => {
              const nameA = (a.supplierType === "Dealer" ? a.dealerName : a.farmerName) || "";
              const nameB = (b.supplierType === "Dealer" ? b.dealerName : b.farmerName) || "";
              return nameA.localeCompare(nameB);
            },
            render: (value, record) => {
              if (record.supplierType === "Dealer") {
                return record.dealerName ? record.dealerName : "-";
              }
              return record.farmerName ? record.farmerName : "-";
            },
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          
        {
          title: "Count",
          key: "count",
          dataIndex: "count",
          responsive: ["md"],
          align: "left",
          render: (value, record) => record.count ?record.count:  "-",
          sorter: (a, b) => (a.count || 0) - (b.count || 0),
        },
          {
            title: "Indent Quantity",
            key: "indentQuantity",
            dataIndex: "indentQuantity",
            render: (value, record) => {
              const quantity = parseFloat(record.indentQuantity);
              return isNaN(quantity) ? "-" : quantity.toFixed(2);
            },
            sorter: (a, b) => a.indentQuantity - b.indentQuantity,
            ...getColumnSearchProps("indentQuantity"),
          },
          {
            title: "GRN Quantity",
            key: "grnQuantity",
            dataIndex: "grnQuantity",
            render: (value, record) => {
              const quantity = parseFloat(record.grnQuantity);
              return isNaN(quantity) ? "-" : quantity.toFixed(2);
            },
            sorter: (a, b) => a.grnQuantity - b.grnQuantity,
            ...getColumnSearchProps("grnQuantity"),
          },
          ...(selectedTest === "GRADING"
            ? [
             
              {
                title: "HON Quantity",
                key: "HONQuantity",
                dataIndex: "HONQuantity",
                render: (value, record) => {
                  const quantity = parseFloat(record.HONQuantity);
                  return isNaN(quantity) ? "-" : quantity.toFixed(2);
                },
                sorter: (a, b) => a.HONQuantity - b.HONQuantity,
                ...getColumnSearchProps("HONQuantity"),
              },
              ]
            : []),
            {
              title: "Boxes",
              key: "boxes",
              dataIndex: "boxes",
              render: (value, record) => (record.boxes ? record.boxes : "-"),
              sorter: (a, b) => a.boxes - b.boxes,
              ...getColumnSearchProps("boxes"),
            },

          {
            title: "Sampler Name",
            key: "samplerName",
            dataIndex: "samplerName",
            render: (value, record) => record.samplerName ?record.samplerName :  "-",
            sorter: (a, b) => a.samplerName?.localeCompare(b.samplerName),
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          {
            title: 'CAP',
            key: 'cap',
            dataIndex:'cap',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('cap'),
            // sorter: (a, b) => a.cap?.localeCompare(b.cap),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.cap === value,

        },
        {
          title: 'CAP Value',
          key: 'capValue',
         dataIndex: 'capValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('capValue'),
          render: (value) => (value !== null && value !== undefined ? value : '-'),
     


      },
        {
            title: 'AOZ',
            key: 'aoz',
            dataIndex: 'aoz',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('aoz'),
            // sorter:(a,b) => a.aoz.localeCompare(b.aoz),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.aoz === value,
        },
        {
          title: 'AOZ Value',
          key: 'aozValue',
          dataIndex: 'aozValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('aozValue'),
          sorter: (a, b) => a.aozValue-b.aozValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.aozValue ? record.aozValue : "-"),


      },
        
        {
            title: 'AMOZ',
            key: 'amoz',
            dataIndex: 'amoz',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('amoz'),
            // sorter: (a, b) => a.amoz-b.amoz,
            // sortDirections: ['descend', 'ascend'],
            render: (value, record) => record.amoz ?record.amoz :  "-",
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.amoz === value,
            // render:(index,val) =>{
            //     return <span>{val.amoz?moment(val.amoz).format("DD-MM-YYYY"):'-'}</span>
            // }



        },
        {
          title: 'AMOZ Value',
          key: 'amozValue',
          dataIndex: 'amozValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('amozValue'),
          sorter: (a, b) => a.amozValue -b.amozValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.amozValue ? record.amozValue : "-"),


      },
        
        {
            title: 'SEM',
            key: 'sem',
           dataIndex: 'sem',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('sem'),
            // sorter: (a, b) => a.sem-b.sem,
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.sem === value,


        },
        {
          title: 'SEM Value',
          key: 'semValue',
          dataIndex: 'semValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('semValue'),
          sorter: (a, b) => a.semValue-b.semValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.semValue ? record.semValue : "-"),


      },
        {
            title: 'AHD',
            key: 'ahd',
            dataIndex: 'ahd',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('ahd'),
            // sorter: (a, b) => a.ahd.localeCompare(b.ahd),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.ahd === value,

        },
       
      
     
        {
            title: 'AHD Value',
            key: 'ahdValue',
            dataIndex: 'ahdValue',
            responsive: ['md'],
            align: 'left',
            ...getColumnSearchProps('ahdValue'),
            sorter: (a, b) => a.ahdValue?.localeCompare(b.ahdValue),
            sortDirections: ['descend', 'ascend'],
            render: (value, record) => (record.ahdValue ? record.ahdValue : "-"),


        },
        {
          title: "Location",
          key: "location",
          dataIndex: "location",
          responsive: ["md"],
          align: "left",
          sorter: (a, b) => a.location?.localeCompare(b.location),
          render: (value, record) => record.location ?record.location :  "-",
          ...getColumnSearchProps("location"),
        },
        {
          title: "Lab Name",
          key: "labName",
          dataIndex: "labName",
          responsive: ["md"],
          align: "left",
          sorter: (a, b) => a.labName?.localeCompare(b.labName),
          render: (value, record) => record.labName ?record.labName: "-",
          ...getColumnSearchProps("labName"),
        },
        {
          title: "Remarks",
          key: "remarks",
          dataIndex: "remarks",
          responsive: ["md"],
          align: "left",
          render: (text) => (
            <Tooltip title={text || "-"}>
              <span>{text ? (text.length > 10 ? `${text.substring(0, 10)}...` : text) : "-"}</span>
            </Tooltip>
          ),
        },
        {
          title: "Action",
          key: "action",
          responsive: ["md"],
          align: "left",
          render: (text, record) => (
            <Button type="link" icon={<EditOutlined />} onClick={() => handleEdit(record)} />
          ),
        },
      
    ]      

    const completeColumn: ColumnProps<any>[] =  [
      {
        title: 'S No',
        key: 'id',
        responsive: ['md'],
        align: 'left',
        render: (text, object, index) => (page - 1) * 10 + (index + 1),
      },
      
       

        ...(selectedTest === "PRE HARVEST"
          ? [
              {
                title: "Indent Number",
                key: "indentNumber",
                dataIndex: "indentNumber",
                ...getColumnSearchProps("indentNumber"),
                render: (value, record) => record.indentNumber ?record.indentNumber :  "-",
                sorter: (a, b) => a.indentNumber?.localeCompare(b.indentNumber),
                sortDirections: ["descend", "ascend"] as SortOrder[],

              },
              // {
              //   title: "Indent Date",
              //   key: "indentDate",
              //   dataIndex: "indentDate",
              //   width:'120',
              //   sorter: (a, b) => a.indentDate?.localeCompare(b.indentDate),
              //   // ...getColumnSearchProps("indentDate"),
              //   render: (text, record) => {
              //     return (
              //       <>
              //         {record.indentDate ? moment(record.indentDate).format('DD-MM-YYYY') : '-'}
              //       </>
              //     );
              //   },
              // },
            ]
          : []),
          {
            title: 'GRN Number',
            key: 'grnNumber',
            dataIndex:'grnNumber',
            ...getColumnSearchProps('grnNumber'),
            sorter: (a, b) => a.grnNumber?.localeCompare(b.grnNumber),
            render: (value, record) => record.grnNumber ?record.grnNumber :  "-",
            sortDirections: ['descend', 'ascend'] as SortOrder[],
        },
        {
          title: "GRN Date",
          key: "grnDate",
          dataIndex: "grnDate",
          // ...getColumnSearchProps("grnDate"),
          sorter: (a, b) => a.grnDate?.localeCompare(b.grnDate),
          render:(text,record) => {
            return(
              <>
              {record.grnDate ? moment(record.grnDate).format('DD-MM-YYYY') : '-'}
              </>
            )
          }
        },
        ...(selectedTest === "GRADING" ?[
          
            
          {
            title: 'LOT Number',
            key: 'lotNumber',
            dataIndex:'lotNumber',
            ...getColumnSearchProps("lotNumber"),
            sorter: (a, b) => a.lotNumber?.localeCompare(b.lotNumber),
            render: (value, record) => (record.lotNumber ? record.lotNumber : "-"),
            sortDirections: ["descend", "ascend"] as SortOrder[],
            },
        ]:[]),
        {
          title: "Supplier Type",
          key: "supplierType",
          dataIndex: "supplierType",
          ...getColumnSearchProps("supplierType"),
          sorter: (a, b) => a.supplierType?.localeCompare(b.supplierType),
          render: (value, record) => (record.supplierType ? record.supplierType : "-"),
          sortDirections: ["descend", "ascend"] as SortOrder[],
        },
          {
            title: `Supplier Name`,
            key: "farmerName",
            dataIndex: "farmerName",
            ...getColumnSearchProps("farmerName"),
            sorter: (a, b) => {
              const nameA = (a.supplierType === "Dealer" ? a.dealerName : a.farmerName) || "";
              const nameB = (b.supplierType === "Dealer" ? b.dealerName : b.farmerName) || "";
              return nameA.localeCompare(nameB);
            },
            render: (value, record) => {
              if (record.supplierType === "Dealer") {
                return record.dealerName ? record.dealerName : "-";
              }
              return record.farmerName ? record.farmerName : "-";
            },
            sortDirections: ["descend", "ascend"] as SortOrder[],
          },
          
        {
            title: 'Count',
            key: 'count',
            dataIndex:'count',
            responsive: ['md'],
            align: 'left',
            sorter: (a, b) => a.count - b.count,
            render: (value, record) => record.count ?record.count :  "-",
            ...getColumnSearchProps('count'), 
        },

          {
            title: "Indent Quantity",
            key: "indentQuantity",
            dataIndex: "indentQuantity",
            render: (value, record) => {
              const quantity = parseFloat(record.indentQuantity);
              return isNaN(quantity) ? "-" : quantity.toFixed(2);
            },
            sorter: (a, b) => a.indentQuantity - b.indentQuantity,
            ...getColumnSearchProps("indentQuantity"),
          },
          {
            title: "GRN Quantity",
            key: "grnQuantity",
            dataIndex: "grnQuantity",
            render: (value, record) => {
              const quantity = parseFloat(record.grnQuantity);
              return isNaN(quantity) ? "-" : quantity.toFixed(2);
            },
            sorter: (a, b) => a.grnQuantity - b.grnQuantity,
            ...getColumnSearchProps("grnQuantity"),
          },
          ...(selectedTest === "GRADING"
            ? [
             
              {
                title: "HON Quantity",
                key: "HONQuantity",
                dataIndex: "HONQuantity",
                render: (value, record) => {
                  const quantity = parseFloat(record.HONQuantity);
                  return isNaN(quantity) ? "-" : quantity.toFixed(2);
                },
                sorter: (a, b) => a.HONQuantity - b.HONQuantity,
                ...getColumnSearchProps("HONQuantity"),
              },
              ]
            : []),
        {
          title: "Boxes",
          key: "boxes",
          dataIndex: "boxes",
          render: (value, record) => (record.boxes ? record.boxes : "-"),
          sorter: (a, b) => a.boxes - b.boxes,
          ...getColumnSearchProps("boxes"),
        },
        ...(selectedTest === "GRADING"
          ? [
              {
                title: "Sampler Name",
                key: "samplerName",
                dataIndex: "samplerName",
                render: (value, record) => record.samplerName ?record.samplerName :  "-",
                sorter: (a, b) => a.samplerName?.localeCompare(b.samplerName),
                sortDirections: ["descend", "ascend"] as SortOrder[],
              },
            ]
          : []),
     
        {
            title: 'CAP',
            key: 'cap',
            dataIndex:'cap',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('cap'),
            // sorter: (a, b) => a.cap?.localeCompare(b.cap),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.cap === value,

        },
        {
          title: 'CAP Value',
          key: 'capValue',
         dataIndex: 'capValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('capValue'),
          render: (value) => (value !== null && value !== undefined ? value : '-'),
     


      },
        {
            title: 'AOZ',
            key: 'aoz',
            dataIndex: 'aoz',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('aoz'),
            // sorter:(a,b) => a.aoz.localeCompare(b.aoz),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.aoz === value,
        },
        {
          title: 'AOZ Value',
          key: 'aozValue',
          dataIndex: 'aozValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('aozValue'),
          sorter: (a, b) => a.aozValue-b.aozValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.aozValue ? record.aozValue : "-"),


      },
        
        {
            title: 'AMOZ',
            key: 'amoz',
            dataIndex: 'amoz',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('amoz'),
            // sorter: (a, b) => a.amoz-b.amoz,
            // sortDirections: ['descend', 'ascend'],
            render: (value, record) => record.amoz ?record.amoz :  "-",
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.amoz === value,
            // render:(index,val) =>{
            //     return <span>{val.amoz?moment(val.amoz).format("DD-MM-YYYY"):'-'}</span>
            // }



        },
        {
          title: 'AMOZ Value',
          key: 'amozValue',
          dataIndex: 'amozValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('amozValue'),
          sorter: (a, b) => a.amozValue -b.amozValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.amozValue ? record.amozValue : "-"),


      },
        
        {
            title: 'SEM',
            key: 'sem',
           dataIndex: 'sem',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('sem'),
            // sorter: (a, b) => a.sem-b.sem,
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.sem === value,


        },
        {
          title: 'SEM Value',
          key: 'semValue',
          dataIndex: 'semValue',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('semValue'),
          sorter: (a, b) => a.semValue-b.semValue,
          sortDirections: ['descend', 'ascend'],
          render: (value, record) => (record.semValue ? record.semValue : "-"),


      },
        {
            title: 'AHD',
            key: 'ahd',
            dataIndex: 'ahd',
            responsive: ['md'],
            align: 'left',
            // ...getColumnSearchProps('ahd'),
            // sorter: (a, b) => a.ahd.localeCompare(b.ahd),
            // sortDirections: ['descend', 'ascend'],
            filters: [
              { text: 'PASS', value: PassOrFail.PASS },
              { text: 'FAIL', value: PassOrFail.FAIL },
            ],
            onFilter: (value, record) => record.ahd === value,

        },
       
      
     
        {
            title: 'AHD Value',
            key: 'ahdValue',
            dataIndex: 'ahdValue',
            responsive: ['md'],
            align: 'left',
            ...getColumnSearchProps('ahdValue'),
            sorter: (a, b) => a.ahdValue?.localeCompare(b.ahdValue),
            sortDirections: ['descend', 'ascend'],
            render: (value, record) => (record.ahdValue ? record.ahdValue : "-"),


        },
        {
          title: 'Sampler Name',
          key: 'samplerName',
          dataIndex: 'samplerName',
          responsive: ['md'],
          align: 'left',
          ...getColumnSearchProps('samplerName'),
          sorter: (a, b) => a.samplerName?.localeCompare(b.samplerName),
          render: (value, record) => (record.samplerName ? record.samplerName : "-"),
  
  
      },
        {
          title: 'Alloted Lab',
          key: 'allotedLab',
          dataIndex: 'allotedLab',
          responsive: ['md'],
          align: 'left',
          // ...getColumnSearchProps('allotedLab'),
          sorter: (a, b) => a?.allotedLab?.localeCompare(b?.allotedLab),
          sortDirections: ['descend', 'ascend']


      },

      {
        title: 'Location',
        key: 'location',
        dataIndex: 'location',
        responsive: ['md'],
        align: 'left',
        sorter: (a, b) => a.location?.localeCompare(b.location),
        render: (value, record) => (record.location ? record.location : "-"),
        ...getColumnSearchProps('location'),


    },
    {
      title: 'Lab Name',
      key: 'labName',
      dataIndex: 'labName',
      responsive: ['md'],
      align: 'left',
      sorter: (a, b) => a.labName?.localeCompare(b.labName),
      render: (value,record) => (record.labName ? record.labName : '-'),
      ...getColumnSearchProps('labName'),

    },
    {
      title: 'Remarks',
      key: 'remarks',
      dataIndex: 'remarks',
      responsive: ['md'],
      align: 'left',
      render: (text) => (
          <Tooltip title={text}>
              <span>
                  {text?.length > 10 ? `${text.substring(0, 10)}...` : text}
              </span>
          </Tooltip>
      ),
  },
  
      
  {
    title: 'Result',
    key: 'Result',
    dataIndex: 'Result',
    responsive: ['md'],
    align: 'left',
    filters: [
        { text: 'PASS', value: PassOrFail.PASS },
        { text: 'FAIL', value: PassOrFail.FAIL },
    ],
    onFilter: (value, record) => record.Result === value,
    render: (text) => (
        <Tag color={text === PassOrFail.PASS ? 'green' : 'red'}>
            {text}
        </Tag>
    ),
},
{
  title: "Action",
  key: "action",
  render: (_, record) =>
    record.antibioticsTestStatus === "COMPLETED" &&
    record.testAt === 'PRE HARVEST' &&
    record.reweighmentStatus === 0 ? (
        <Popconfirm
          title="Are you sure you want to revert this to processing?"
          onConfirm={() => handleRevert(record)}
          onCancel={() => {}}
          okText="Yes"
          cancelText="No"
        >
          <UndoOutlined
            style={{ color: "blue", cursor: "pointer", width: '50px' }}
          />
        </Popconfirm>
    ) : null,
}
        

    
  ]

    const harvestProcessingData = harvestSecondaryData?.filter(item => item.antibioticsTestStatus === 'PROCESSING') || [];
    const harvestCompletedData = harvestSecondaryData?.filter(item => item.antibioticsTestStatus === 'COMPLETED') || [];
    const gradingProcessingData = gradingSecondaryData?.filter(item => item.antibioticsTestStatus === 'PROCESSING') || [];
    const gradingCompletedData = gradingSecondaryData?.filter(item => item.antibioticsTestStatus === 'COMPLETED') || [];
   
    const onFinish = () => {
      if (selectedTest === "PRE HARVEST") {
        getPreHarvestData();
      } else if (selectedTest === "GRADING") {
        getGradingData();
      }
    };
    const onReset = () => {
      form.resetFields()
      if (selectedTest === "PRE HARVEST") {
        getPreHarvestData();
      } else if (selectedTest === "GRADING") {
        getGradingData();
      }
    };

  return (
    <div>
       <Card
  size="small"
  title={<span style={{ color: 'white' }}>Antibiotic Test Report</span>}
  style={{ textAlign: 'center' }}
  headStyle={{ backgroundColor: '#69c0ff', border: 0 }}
  extra={
    <>
      {/* <Link to="/antibiotics-form">
        <Button className="panel_button">Create</Button>
      </Link> */}
      <Button icon={<DownloadOutlined />} onClick={exportExcel}>
        GET EXCEL
      </Button>
    </>
  }
>

      <Form
        layout="vertical"
        form={form}
      >
        {/* <Row gutter= {24}>
      <Col xs={{ span: 24 }} sm={{ span: 24 }} md={{ span: 5 }} lg={{ span: 6 }} xl={{ span: 6 }}>
                        <Form.Item name="createdAt"
                            label="Date"
                            initialValue={undefined}
                            rules={[{
                                required: false,
                                message: "Transaction Date"
                            },
                            ]}>
                            <RangePicker onChange={handleDateRangeChange} />
                        </Form.Item>
                    </Col>

                    <Col span={3}>
  <Form.Item name="indent" label="INDENT Number" rules={[{ required: false }]}>
    <Select
      showSearch
      optionFilterProp="children"
      filterOption={(input, option) =>
        option.children.toLowerCase().indexOf(input.toLowerCase()) >= 0
      }
      placeholder="Select Indent Number"
      onChange={handleIndentChange} // Capture the selected indent number
      allowClear
    >
      {data
        ? data.map((endCust) => (
            <Option key={endCust.indentNumber} value={endCust.indentNumber}>
              {endCust.indentNumber}
            </Option>
          ))
        : ""}
    </Select>
  </Form.Item>
</Col>

<Col span={3}>
  <Form.Item name="grn" label="GRN Number" rules={[{ required: false }]}>
    <Select
      showSearch
      optionFilterProp="children"
      filterOption={(input, option) =>
        option.children.toLowerCase().indexOf(input.toLowerCase()) >= 0
      }
      placeholder="Select grn Number"
      onChange={handlegrnChange} // Capture the selected indent number
      allowClear
    >
      {data
        ? data.map((endCust) => (
            <Option key={endCust.grn_number} value={endCust.grn_number}>
              {endCust.grn_number}
            </Option>
          ))
        : ""}
    </Select>
  </Form.Item>
</Col>


<Col span={3}>
<Form.Item name="lot" label="LOT Number" rules={[{ required: false }]}>
  <Select
    showSearch
    optionFilterProp="children"
    filterOption={(input, option) =>
      option.children.toLowerCase().indexOf(input.toLowerCase()) >= 0
    }
    placeholder="Select lot Number"
    onChange={handleLotChange} // Capture the selected lot number
    allowClear
  >
    {data && data.length > 0
      ? data
          .filter((endCust) => endCust.lotNumber && endCust.lotNumber.trim() !== "") // Filter out empty lotNumber
          .reduce((unique, endCust) => {
            // Check if the lotNumber already exists in the unique list
            if (!unique.some((cust) => cust.lotNumber === endCust.lotNumber)) {
              unique.push(endCust);
            }
            return unique;
          }, [])
          .map((endCust) => (
            <Option key={endCust.lotNumber} value={endCust.lotNumber}>
              {endCust.lotNumber}
            </Option>
          ))
      : null}
  </Select>
</Form.Item>


  </Col>

  <Col span={3}>
  <Form.Item 
  label="TEST Result" 
  name="testResult" 
>
  <Select 
    placeholder="Select Test Result" 
    allowClear
    onChange={handleStatusChange} // Capture the selected indent number

  >
    <Option value={PassOrFail.PASS}>PASS</Option>
    <Option value={PassOrFail.FAIL}>FAIL</Option>
  </Select>
</Form.Item>
</Col>



<Col span={3}>
  <Form.Item 
  label="Alloted Lab" 
  name="allotedLab" 
>
  <Select 
    placeholder="Select Alloted Lab" 
    allowClear
    onChange={handleAllcatedLabChange}

  >
    <Option value={AllocatedLab.EXTERNAL}>EXTERNAL</Option>
    <Option value={AllocatedLab.INHOUSE}>INHOUSE</Option>
  </Select>
</Form.Item>
</Col>   
</Row> */}
{/* <Row>
<Col span={3}>
            <Button type="primary" onClick={handleSearch1} style={{ marginRight: 30,marginTop :28}}>
              Search
            </Button>
            <Button onClick={handleReset1} style={{ marginRight: -60,marginTop :28}}>Reset</Button>
          </Col>
          </Row> */}

          <Col xs={24} sm={24} md={6} lg={6} xl={6} style={{ marginTop:'15px',}}>
          <Text style={{color:'black'}} strong>Test As : </Text>
          <Select
            placeholder="Select test At"
            onChange={handleFormTypeChange}
            value={selectedTest}
            style={{width:'200px'}}
          >
            <Option value="PRE HARVEST">PRE HARVEST</Option>
            <Option value="GRADING">GRADING</Option>
          </Select>

      </Col>
        
      </Form>
      </Card>
      <Tabs defaultActiveKey="1" centered onChange={handleTabChange}>
                  <TabPane tab="Pending" key="1" >
                  
                    {
                      selectedTest=== 'GRADING' ?
                    <>
                    <Form form={form} onFinish={onFinish}>
                <Row gutter={24}>
                
                  {selectedTest === "GRADING" && (
                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                    <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>)}
                  <Col>
                    <Form.Item>
                      <Button
                        type="primary"
                        htmlType="submit"
                        style={{ background: "green", width: "100%" }}
                      >
                        Search
                      </Button>
                    </Form.Item>
                  </Col>
                  <Col>
                    <Form.Item>
                      <Button
                        danger
                        // icon={<UndoOutlined />}
                        onClick={onReset}
                        style={{ width: "100%" }}
                      >
                        Reset
                      </Button>
                    </Form.Item>
                  </Col>
                </Row>
              </Form><Table
                  columns={gradingPendingColumn}
                  dataSource={pendingData}
                  scroll={{ x: 'max-content' }}
                  pagination={{
                    current: page,
                    onChange: (current) => setPage(current),
                  }} /></> 
                    :
                    <><Form form={form} onFinish={onFinish}>
                <Row gutter={24}>

                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                      <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>
                  <Col>
                    <Form.Item>
                      <Button
                        type="primary"
                        htmlType="submit"
                        style={{ background: "green", width: "100%" }}
                      >
                        Search
                      </Button>
                    </Form.Item>
                  </Col>
                  <Col>
                    <Form.Item>
                      <Button
                        danger
                        // icon={<UndoOutlined />}
                        onClick={onReset}
                        style={{ width: "100%" }}
                      >
                        Reset
                      </Button>
                    </Form.Item>
                  </Col>
                </Row>
              </Form><Table
                  columns={harvestPendingColumn}
                  dataSource={pendingData}
                  scroll={{ x: 'max-content' }}
                  pagination={{
                    current: page,
                    onChange: (current) => setPage(current),
                  }}
              /> 
                  </> 
                    }
                    
                </TabPane>
                <TabPane tab="Processing" key="2">
                <><Form form={form} onFinish={onFinish}>
                <Row gutter={24}>
                {selectedTest === "PRE HARVEST" && (
                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                      <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>)}
                  {selectedTest === "GRADING" && (
                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                      <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>)}
                  <Col>
                    <Form.Item>
                      <Button
                        type="primary"
                        htmlType="submit"
                        style={{ background: "green", width: "100%" }}
                      >
                        Search
                      </Button>
                    </Form.Item>
                  </Col>
                  <Col>
                    <Form.Item>
                      <Button
                        danger
                        // icon={<UndoOutlined />}
                        onClick={onReset}
                        style={{ width: "100%" }}
                      >
                        Reset
                      </Button>
                    </Form.Item>
                  </Col>
                </Row>
              </Form></>
                    <Table
                        columns={processingColumn}
                        dataSource={selectedTest === "GRADING" ? gradingProcessingData : harvestProcessingData}
                        scroll={{ x: 'max-content' }}
                        pagination={{
                          current: page,
                          onChange: (current) => setPage(current),
                        }}
                    /> 
                </TabPane>
                <TabPane tab="Completed" key="3">
                <><Form form={form} onFinish={onFinish}>
                <Row gutter={24}>

                {selectedTest === "PRE HARVEST" && (
                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                      <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>)}
                  {selectedTest === "GRADING" && (
                  <Col>
                    <Form.Item label="GRN Date" name="grnDate">
                      <RangePicker
                      disabledDate={(current) => {
                        const minDate = new Date('2025-03-15'); 
                        const maxDate = new Date(); 

                        return current && (current.isBefore(minDate, 'day') || current.isAfter(maxDate, 'day'));
                         }}
                        />
                    </Form.Item>
                  </Col>)}
                  <Col>
                    <Form.Item>
                      <Button
                        type="primary"
                        htmlType="submit"
                        style={{ background: "green", width: "100%" }}
                      >
                        Search
                      </Button>
                    </Form.Item>
                  </Col>
                  <Col>
                    <Form.Item>
                      <Button
                        danger
                        // icon={<UndoOutlined />}
                        onClick={onReset}
                        style={{ width: "100%" }}
                      >
                        Reset
                      </Button>
                    </Form.Item>
                  </Col>
                </Row>
              </Form></>
                    <Table
                        columns={completeColumn}
                        dataSource={selectedTest === "GRADING" ? gradingCompletedData : harvestCompletedData}
                        scroll={{ x: 'max-content' }}
                        pagination={{
                          current: page,
                          onChange: (current) => setPage(current),
                        }}
                    /> 
                </TabPane>
            </Tabs>
      {/* <Table
      columns={columnLine}
      dataSource={data}
      scroll={{ x: true }}
      pagination={{
          onChange(current) {
            setPage(current);
          }
      }}
      ></Table> */}
       
        {selectedRecord &&  <AntiBioticsMicrobiologyForms setSelectedRecord={setSelectedRecord} setIsModalVisible={setIsModalVisible} isModalVisible={isModalVisible} grnInfo={selectedRecord} type={selectedTest} handleCancel={handleCancel} isUpdating={wasCreating ? false : true } setRefreshKey={setRefreshKey}/>}
      

    </div>
  )
}

export default AntiBioticsView