import { reactive, computed } from "vue";
import { onBeforeRouteLeave } from "vue-router";
import { useQuery } from "@tanstack/vue-query";
import { useV } from "@studio-m/common/src/utils/validations";
import { CreateShootingDTO } from "@studio-m/app-types/src/shooting.types";
import {
  requiredRule,
  requiredIfRule,
} from "@studio-m/common/src/utils/validations";
import { requests } from "../../../api/agent";
import { queryKeys } from "../../../api/query-keys";
import { useInvalidateShootings } from "./use-invalidate-shootings";
import { BaseComposableOption } from "../../../types/composable.types";

export const useCreateShooting = (options: BaseComposableOption = {}) => {
  const { invalidateShootings } = useInvalidateShootings();

  const toInputDate = (value?: string) => {
    if (!value) return "";
    const parsed = new Date(value);
    return isNaN(parsed.getTime()) ? "" : parsed.toISOString().slice(0, 10);
  };

  const createInitialPayload = (): CreateShootingDTO => ({
    name: options.payload?.name || "",
    description:
      toInputDate(options.payload?.description) ||
      new Date().toISOString().slice(0, 10),
    customerId: options.payload?.customer?.id || "",
    masonryMode: options.payload?.masonryMode || false,
    allowDownload:
      options.payload?.allowDownload !== undefined
        ? options.payload.allowDownload
        : true,
    customer: {
      firstname: "",
      lastname: "",
      email: "",
      phone: "",
      address: "",
      city: "",
      zipcode: "",
    },
  });

  const payload = reactive<CreateShootingDTO>(createInitialPayload());

  const rules = computed(() => ({
    name: { requiredRule },
    description: { requiredRule },
    customerId: {
      requiredIfRule: requiredIfRule(!payload.customer?.firstname),
    },
    customer: {
      firstname: {
        requiredIfRule: requiredIfRule(!payload.customerId),
      },
      lastname: {
        requiredIfRule: requiredIfRule(!payload.customerId),
      },
      email: {
        requiredIfRule: requiredIfRule(!payload.customerId),
      },
      phone: {},
      address: {},
      city: {},
      zipcode: {},
    },
  }));

  const query = useQuery({
    queryKey: queryKeys.shootings.create,
    queryFn: async () => {
      if (options?.payload?.id) {
        return await requests.put(`shootings/${options?.payload?.id}`, {
          id: options?.payload?.id,
          ...payload,
        });
      }

      return await requests.post("shootings", payload);
    },
    enabled: false,
  });

  const createShooting = async () => {
    try {
      const result = await query.refetch();
      if (result.data) {
        await invalidateShootings();
        options.onSuccess?.(result.data);
      }
    } catch (e) {
      console.error(e);
      options.onError?.(e);
    }
  };

  const v = useV(payload, rules, {
    onSubmit: () => {
      createShooting();
    },
  });

  const resetForm = () => {
    const initialPayload = createInitialPayload();
    payload.name = initialPayload.name;
    payload.description = initialPayload.description;
    payload.customerId = initialPayload.customerId;
    payload.masonryMode = initialPayload.masonryMode;
    payload.allowDownload = initialPayload.allowDownload;
    if (payload.customer) {
      Object.assign(payload.customer, initialPayload.customer);
    } else {
      payload.customer = initialPayload.customer;
    }
    v.v.value.$reset?.();
    options.onReset?.();
  };

  onBeforeRouteLeave(() => {
    resetForm();
  });

  return {
    createShooting,
    payload,
    query,
    v,
    resetForm,
  };
};
