"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

function _react() {
  const data = _interopRequireWildcard(require("react"));

  _react = function () {
    return data;
  };

  return data;
}

function _jsxRuntime() {
  const data = require("react/jsx-runtime");

  _jsxRuntime = function () {
    return data;
  };

  return data;
}

function _clsx() {
  const data = _interopRequireDefault(require("clsx"));

  _clsx = function () {
    return data;
  };

  return data;
}

var _ConfigProviderContext = _interopRequireDefault(require("../config-provider/ConfigProviderContext"));

var _picker = _interopRequireDefault(require("../picker"));

var _hooks = require("../hooks");

var _deepClone = require("../utils/deep-clone");

var _utils = require("../utils");

var _raf = require("../utils/raf");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

/* eslint-disable no-plusplus */
const EMPTY_CODE = '000000';
const INHERIT_PROPS = ['title', 'loading', 'readonly', 'itemHeight', 'swipeDuration', 'visibleItemCount', 'cancelButtonText', 'confirmButtonText', 'toolbar', 'columnsTop', 'columnsBottom', 'optionRender'];
const Area = (0, _react().forwardRef)((props, ref) => {
  const {
    prefixCls,
    createNamespace
  } = (0, _react().useContext)(_ConfigProviderContext.default);
  const [bem] = createNamespace('area', prefixCls);
  const pickerRef = (0, _react().useRef)();
  const [state, updateState, stateRef] = (0, _hooks.useSetState)({
    code: props.value,
    columns: [{
      values: []
    }, {
      values: []
    }, {
      values: []
    }]
  });
  const areaList = (0, _react().useMemo)(() => {
    return {
      province: props.areaList.province_list || {},
      city: props.areaList.city_list || {},
      county: props.areaList.county_list || {}
    };
  }, [JSON.stringify(props.areaList)]);
  const placeholderMap = (0, _react().useMemo)(() => {
    const {
      columnsPlaceholder
    } = props;
    return {
      province: columnsPlaceholder[0] || '',
      city: columnsPlaceholder[1] || '',
      county: columnsPlaceholder[2] || ''
    };
  }, [props.columnsPlaceholder]);

  const getDefaultCode = () => {
    if (props.columnsPlaceholder.length) {
      return EMPTY_CODE;
    }

    const {
      county,
      city
    } = areaList;
    const countyCodes = Object.keys(county);

    if (countyCodes[0]) {
      return countyCodes[0];
    }

    const cityCodes = Object.keys(city);

    if (cityCodes[0]) {
      return cityCodes[0];
    }

    return '';
  };

  const getColumnValues = (type, code) => {
    let column = [];

    if (type !== 'province' && !code) {
      return column;
    }

    const list = areaList[type];
    column = Object.keys(list).map(listCode => ({
      code: listCode,
      name: list[listCode]
    }));

    if (code) {
      // oversea code
      if (type === 'city' && props.isOverseaCode(code)) {
        code = '9';
      }

      column = column.filter(item => item.code.indexOf(code) === 0);
    }

    if (placeholderMap[type] && column.length) {
      // set columns placeholder
      let codeFill = '';

      if (type === 'city') {
        codeFill = EMPTY_CODE.slice(2, 4);
      } else if (type === 'county') {
        codeFill = EMPTY_CODE.slice(4, 6);
      }

      column.unshift({
        code: code + codeFill,
        name: placeholderMap[type]
      });
    }

    return column;
  }; // get index by code


  const getIndex = (type, code) => {
    let compareNum = code.length;

    if (type === 'province') {
      compareNum = props.isOverseaCode(code) ? 1 : 2;
    }

    if (type === 'city') {
      compareNum = 4;
    }

    code = code.slice(0, compareNum);
    const list = getColumnValues(type, compareNum > 2 ? code.slice(0, compareNum - 2) : '');

    for (let i = 0; i < list.length; i++) {
      if (list[i].code.slice(0, compareNum) === code) {
        return i;
      }
    }

    return 0;
  };

  const setValues = () => {
    let code = stateRef.current.code || getDefaultCode();
    const picker = pickerRef.current;
    const province = getColumnValues('province');
    const city = getColumnValues('city', code.slice(0, 2));

    if (!picker) {
      return;
    }

    picker.setColumnValues(0, province);
    picker.setColumnValues(1, city);

    if (city.length && code.slice(2, 4) === '00' && !props.isOverseaCode(code)) {
      [{
        code
      }] = city;
    }

    picker.setColumnValues(2, getColumnValues('county', code.slice(0, 4)));
    picker.setIndexes([getIndex('province', code), getIndex('city', code), getIndex('county', code)]);
  }; // parse output columns data


  const parseValues = values => values.map((value, index) => {
    if (value) {
      value = (0, _deepClone.deepClone)(value);

      if (!value.code || value.name === props.columnsPlaceholder[index]) {
        value.code = '';
        value.name = '';
      }
    }

    return value;
  });

  const getValues = () => {
    var _a;

    if (pickerRef.current) {
      const values = (_a = pickerRef.current) === null || _a === void 0 ? void 0 : _a.getValues().filter(Boolean);
      return parseValues(values);
    }

    return [];
  };

  const getArea = () => {
    const values = getValues();
    const area = {
      code: '',
      country: '',
      province: '',
      city: '',
      county: ''
    };

    if (!values.length) {
      return area;
    }

    const names = values.map(item => item.name);
    const validValues = values.filter(value => value.code);
    area.code = validValues.length ? validValues[validValues.length - 1].code : '';

    if (props.isOverseaCode(area.code)) {
      area.country = names[1] || '';
      area.province = names[2] || '';
    } else {
      area.province = names[0] || '';
      area.city = names[1] || '';
      area.county = names[2] || '';
    }

    return area;
  };

  const reset = (newCode = '') => {
    updateState({
      code: newCode
    });
    setValues();
  };

  const onChange = (values, index) => {
    var _a;

    updateState({
      code: values[index].code
    });
    setValues();

    if (pickerRef.current) {
      const parsedValues = parseValues((_a = pickerRef.current) === null || _a === void 0 ? void 0 : _a.getValues());
      if (props.onChange) props.onChange(parsedValues, index);
    }
  };

  const onConfirm = (values, index) => {
    setValues();
    if (props.onConfirm) props.onConfirm(parseValues(values), index);
  };

  const onCancel = (...args) => {
    if (props.onCancel) props.onCancel(...args);
  };

  (0, _hooks.useMount)(setValues);
  (0, _hooks.useUpdateEffect)(() => {
    updateState({
      code: props.value
    });
    setValues();
  }, [props.value]);
  (0, _hooks.useUpdateEffect)(() => {
    setValues();
  }, [props.areaList, props.columnsNum]);
  (0, _react().useEffect)(() => {
    (0, _raf.raf)(() => {
      setValues();
    });
  }, [props.columnsNum]);
  (0, _react().useImperativeHandle)(ref, () => ({
    reset,
    getArea,
    getValues
  }));
  const columns = state.columns.slice(0, +props.columnsNum);
  return (0, _jsxRuntime().jsx)(_picker.default, Object.assign({
    ref: pickerRef,
    className: (0, _clsx().default)(bem()),
    columns: columns,
    columnsFieldNames: {
      text: 'name'
    },
    onChange: onChange,
    onCancel: onCancel,
    onConfirm: onConfirm
  }, (0, _utils.pick)(props, INHERIT_PROPS)));
});

function isOverseaCode(code) {
  return code[0] === '9';
}

Area.defaultProps = {
  areaList: {},
  columnsNum: 3,
  columnsPlaceholder: [],
  isOverseaCode
};
var _default = Area;
exports.default = _default;