import { createValidationReaction } from '../tools';
import type { ProcessContext } from '../types';
import helper from './lib/helper';
import { createValidationSchema } from './validation';
import { getTransTax } from '@/api/1c/query';
import { selectObjectCategoryTax } from '@/config/default-options';
import { STALE_TIME } from '@/constants/request';
import * as CRMTypes from '@/graphql/crm.types';
import { getCurrentDateString } from '@/utils/date';
import { normalizeOptions } from '@/utils/entity';
import { disposableReaction } from '@/utils/mobx';
import { reaction } from 'mobx';

export function common({ store, apolloClient, queryClient }: ProcessContext) {
  const { $calculation, $process } = store;

  reaction(
    () => $calculation.$values.getValues(['leaseObjectType', 'supplierFinancing']),
    async ({ leaseObjectType: leaseObjectTypeId, supplierFinancing }) => {
      if (!leaseObjectTypeId) {
        $calculation.element('radioObjectRegistration').resetValue().unblock();

        return;
      }
      const {
        data: { evo_leasingobject_type },
      } = await apolloClient.query({
        query: CRMTypes.GetLeaseObjectTypeDocument,
        variables: { leaseObjectTypeId },
      });

      if (
        supplierFinancing ||
        (evo_leasingobject_type?.evo_id &&
          ['6', '9', '10', '11'].includes(evo_leasingobject_type.evo_id))
      ) {
        $calculation.element('radioObjectRegistration').setValue(100_000_000).block();
      } else {
        $calculation.element('radioObjectRegistration').unblock();
      }
    }
  );

  disposableReaction(
    () => $process.has('LoadKP'),
    () =>
      $calculation.$values.getValues([
        'leaseObjectType',
        'objectCategoryTax',
        'objectRegistration',
      ]),
    async ({ leaseObjectType: leaseObjectTypeId, objectRegistration, objectCategoryTax }) => {
      if (objectRegistration === 100_000_001) {
        if (objectCategoryTax && [100_000_006, 100_000_009].includes(objectCategoryTax)) {
          $calculation.element('selectObjectTypeTax').setValue(100_000_002);
        } else if (leaseObjectTypeId) {
          const {
            data: { evo_leasingobject_type },
          } = await apolloClient.query({
            query: CRMTypes.GetLeaseObjectTypeDocument,
            variables: { leaseObjectTypeId },
          });

          if (evo_leasingobject_type?.evo_vehicle_type_tax) {
            $calculation
              .element('selectObjectTypeTax')
              .setValue(evo_leasingobject_type?.evo_vehicle_type_tax);
          } else {
            $calculation.element('selectObjectTypeTax').resetValue();
          }
        }
      } else {
        $calculation.element('selectObjectTypeTax').resetValue();
      }
    }
  );

  reaction(
    () =>
      $calculation.$values.getValues([
        'leaseObjectType',
        'leaseObjectCategory',
        'typePTS',
        'objectRegistration',
      ]),
    async ({
      leaseObjectType: leaseObjectTypeId,
      leaseObjectCategory,
      typePTS,
      objectRegistration,
    }) => {
      if (!(objectRegistration === 100_000_001 && typePTS === 100_000_001) || !leaseObjectTypeId) {
        $calculation.element('selectObjectCategoryTax').resetOptions().resetValue().block();

        return;
      }

      const {
        data: { evo_leasingobject_type },
      } = await apolloClient.query({
        query: CRMTypes.GetLeaseObjectTypeDocument,
        variables: { leaseObjectTypeId },
      });
      if (leaseObjectCategory && leaseObjectCategory === evo_leasingobject_type?.evo_category) {
        $calculation
          .element('selectObjectCategoryTax')
          .setOptions(
            selectObjectCategoryTax.filter((option) =>
              evo_leasingobject_type?.evo_category_tr?.includes(option.value)
            )
          )
          .unblock();
      }
    },
    {
      fireImmediately: true,
    }
  );

  reaction(
    () => $calculation.$values.getValues(['leasingPeriod', 'vehicleTaxInYear']),
    ({ leasingPeriod, vehicleTaxInYear }) => {
      if (vehicleTaxInYear > 0) {
        $calculation
          .element('tbxVehicleTaxInLeasingPeriod')
          .setValue((vehicleTaxInYear / 12) * leasingPeriod);
      } else {
        $calculation.element('tbxVehicleTaxInLeasingPeriod').resetValue();
      }
    }
  );

  const mapObjectTypeTaxToCategory = {
    100_000_000: 'D',
    100_000_001: 'B',
    100_000_002: 'C',
    100_000_003: 'T',
    100_000_004: 'A',
  };

  function getCarCategory(objectTypeTax: number) {
    return mapObjectTypeTaxToCategory[objectTypeTax as keyof typeof mapObjectTypeTaxToCategory];
  }

  disposableReaction(
    () => $process.has('LoadKP'),
    () =>
      $calculation.$values.getValues([
        'objectRegistration',
        'objectTypeTax',
        'regionRegistration',
        'leaseObjectYear',
        'leaseObjectMotorPower',
      ]),
    async ({
      objectRegistration,
      objectTypeTax,
      regionRegistration,
      leaseObjectYear,
      leaseObjectMotorPower,
    }) => {
      if (
        objectRegistration === null ||
        objectRegistration !== 100_000_001 ||
        objectTypeTax === null ||
        regionRegistration === null ||
        leaseObjectYear === 0 ||
        leaseObjectMotorPower === 0
      ) {
        $calculation.element('tbxVehicleTaxInYear').resetValue();

        return;
      }

      const {
        data: { evo_region },
      } = await apolloClient.query({
        query: CRMTypes.GetRegionDocument,
        variables: {
          regionId: regionRegistration,
        },
      });

      const OKTMO = evo_region?.evo_oktmo;
      const carCategory = getCarCategory(objectTypeTax);

      if (OKTMO) {
        const response = await queryClient.fetchQuery(
          ['1c', 'trans-tax', carCategory, leaseObjectMotorPower, leaseObjectYear, OKTMO],
          (context) =>
            getTransTax(
              {
                CalcDate: getCurrentDateString(),
                CarCategory: carCategory,
                OKTMO,
                Power: leaseObjectMotorPower,
                Year: leaseObjectYear,
              },
              context
            ),
          {
            staleTime: STALE_TIME,
          }
        );

        if (response?.Tax) {
          $calculation.element('tbxVehicleTaxInYear').setValue(response.Tax);
        } else {
          $calculation.element('tbxVehicleTaxInYear').resetValue();
        }
      } else {
        $calculation.element('tbxVehicleTaxInYear').resetValue();
      }
    }
  );

  // Не дышать на реакцию
  reaction(
    () =>
      $calculation.$values.getValues([
        'objectRegionRegistration',
        'objectRegistration',
        'regionRegistration',
        'typePTS',
        'leaseObjectCategory',
        'leaseObjectType',
      ]),
    async ({
      objectRegistration,
      objectRegionRegistration: objectRegionRegistrationId,
      regionRegistration: regionRegistrationId,
      typePTS,
      leaseObjectCategory,
      leaseObjectType,
      // eslint-disable-next-line sonarjs/cognitive-complexity
    }) => {
      let evo_region: CRMTypes.GetRegionQuery['evo_region'];
      if (objectRegionRegistrationId) {
        const { data } = await apolloClient.query({
          query: CRMTypes.GetRegionDocument,
          variables: { regionId: objectRegionRegistrationId },
        });
        evo_region = data.evo_region;
      }

      const {
        data: { evo_addproduct_types },
      } = await apolloClient.query({
        query: CRMTypes.GetRegistrationTypesDocument,
        variables: { currentDate: getCurrentDateString() },
      });

      const options = evo_addproduct_types?.filter((x) => {
        if (
          !x?.evo_leasingobject_types?.find(
            (evo_leasingobject_type) =>
              evo_leasingobject_type?.evo_leasingobject_typeid === leaseObjectType
          )
        ) {
          return false;
        }

        if (!objectRegionRegistrationId && !regionRegistrationId) {
          return false;
        }

        if (!(x?.evo_whom_register === objectRegistration)) {
          return false;
        }

        if (leaseObjectCategory !== 100_000_001 && x?.evo_towtruck) {
          return false;
        }

        if (!(x?.evo_gibdd_region === (objectRegionRegistrationId === regionRegistrationId))) {
          return false;
        }

        if (
          (typePTS &&
            (!x?.evo_pts_type ||
              x?.evo_pts_type.filter((evo_pts_type) => evo_pts_type > 0).length === 0)) ||
          (typePTS &&
            x?.evo_pts_type?.filter((evo_pts_type) => evo_pts_type > 0).includes(typePTS) === false)
        ) {
          return false;
        }

        if (!x?.evo_accountid) {
          return true;
        }

        return evo_region?.accounts
          ?.map((evo_region_account) => evo_region_account?.accountid)
          .includes(x.evo_accountid);
      });

      $calculation.element('selectRegistration').setOptions(normalizeOptions(options));
    }
  );

  reaction(
    () => $calculation.element('selectRegistration').getValue(),
    async (registrationId) => {
      if (!registrationId) {
        $calculation.element('labelRegistrationDescription').resetValue();

        return;
      }

      const {
        data: { evo_addproduct_type },
      } = await apolloClient.query({
        query: CRMTypes.GetAddProductTypeDocument,
        variables: { addproductTypeId: registrationId },
      });

      if (evo_addproduct_type?.evo_description) {
        $calculation
          .element('labelRegistrationDescription')
          .setValue(evo_addproduct_type?.evo_description);
      } else {
        $calculation.element('labelRegistrationDescription').resetValue();
      }
    }
  );

  reaction(
    () => $calculation.element('selectLegalClientRegion').getValue(),
    async (regionId) => {
      if (!regionId) {
        $calculation.element('selectLegalClientTown').resetOptions();

        return;
      }
      const {
        data: { evo_towns },
      } = await apolloClient.query({
        query: CRMTypes.GetTownsDocument,
        variables: { regionId },
      });

      $calculation.element('selectLegalClientTown').setOptions(normalizeOptions(evo_towns));
    }
  );

  reaction(
    () => $calculation.$values.getValues(['regionRegistration', 'objectRegistration']),
    async ({ regionRegistration: regionId, objectRegistration }) => {
      if (!regionId) {
        $calculation.element('selectTownRegistration').resetOptions();

        return;
      }
      const {
        data: { evo_towns },
      } = await apolloClient.query({
        query: CRMTypes.GetTownsDocument,
        variables: { regionId },
      });

      if (objectRegistration === 100_000_001) {
        const towns = evo_towns?.filter((x) => x?.evo_businessunit_evolution === true);
        $calculation.element('selectTownRegistration').setOptions(normalizeOptions(towns));
      } else {
        $calculation.element('selectTownRegistration').setOptions(normalizeOptions(evo_towns));
      }
    }
  );

  reaction(
    () => $calculation.$values.getValues(['objectRegistration']),
    async ({ objectRegistration }) => {
      const {
        data: { evo_regions },
      } = await apolloClient.query({
        query: CRMTypes.GetRegionsDocument,
      });

      if (objectRegistration === 100_000_001) {
        const regions = evo_regions?.filter((x) => x?.evo_businessunit_evolution === true);
        $calculation.element('selectRegionRegistration').setOptions(normalizeOptions(regions));
      } else {
        $calculation.element('selectRegionRegistration').setOptions(normalizeOptions(evo_regions));
      }
    }
  );

  const { getData } = helper({ apolloClient });

  reaction(
    () => $calculation.$values.getValues(['lead', 'opportunity']),
    async ({ lead, opportunity }) => {
      const { account } = await getData({ lead, opportunity });

      if (account.evo_legal_regionid) {
        $calculation
          .element('selectLegalClientRegion')
          .setValue(account.evo_legal_regionid)
          .block();
      } else {
        $calculation.element('selectLegalClientRegion').resetValue().unblock();
      }

      if (account.evo_legal_townid) {
        $calculation.element('selectLegalClientTown').setValue(account.evo_legal_townid).block();
      } else {
        $calculation.element('selectLegalClientTown').resetValue().unblock();
      }
    },
    {
      delay: 50,
    }
  );

  reaction(
    () => $calculation.$values.getValues(['lead', 'opportunity', 'objectRegistration']),
    async ({ lead, objectRegistration, opportunity }) => {
      const { account } = await getData({ lead, opportunity });

      if (objectRegistration === 100_000_000 && account.evo_regionid) {
        $calculation.element('selectRegionRegistration').setValue(account.evo_regionid).block();
      } else {
        $calculation.element('selectRegionRegistration').unblock();
      }

      if (objectRegistration === 100_000_000 && account.evo_townid) {
        $calculation.element('selectTownRegistration').setValue(account.evo_townid).block();
      } else {
        $calculation.element('selectTownRegistration').unblock();
      }
    },
    {
      delay: 50,
    }
  );

  reaction(
    () => $calculation.element('radioObjectRegistration').getValue(),
    (objectRegistration) => {
      if (objectRegistration === 100_000_000) {
        $calculation.element('tbxVehicleTaxInYear').resetValue().block();
        $calculation.element('radioTypePTS').resetValue().block();
      } else {
        $calculation.element('tbxVehicleTaxInYear').unblock();
        $calculation.element('radioTypePTS').unblock();
      }
    },
    {
      fireImmediately: true,
    }
  );
}

export const validation = createValidationReaction(createValidationSchema);