/***************************************************************************
 * The contents of this file were generated with Amplify Studio.           *
 * Please refrain from making any modifications to this file.              *
 * Any changes to this file will be overwritten when running amplify pull. *
 **************************************************************************/

/* eslint-disable */
import * as React from "react";
import { Button, Flex, Grid, TextField } from "@aws-amplify/ui-react";
import { getOverrideProps } from "@aws-amplify/ui-react/internal";
import { AWSChannelPool } from "../models";
import { fetchByPath, validateField } from "./utils";
import { DataStore } from "aws-amplify";
export default function AWSChannelPoolUpdateForm(props) {
  const {
    id: idProp,
    aWSChannelPool: aWSChannelPoolModelProp,
    onSuccess,
    onError,
    onSubmit,
    onValidate,
    onChange,
    overrides,
    ...rest
  } = props;
  const initialValues = {
    channelId: "",
    ingestServer: "",
    streamKey: "",
    inputId: "",
    playbackUrl: "",
    channelStatus: "",
    videoId: "",
    createdAt: "",
    updatedAt: "",
    aliveToken: "",
    alivedAt: "",
  };
  const [channelId, setChannelId] = React.useState(initialValues.channelId);
  const [ingestServer, setIngestServer] = React.useState(
    initialValues.ingestServer
  );
  const [streamKey, setStreamKey] = React.useState(initialValues.streamKey);
  const [inputId, setInputId] = React.useState(initialValues.inputId);
  const [playbackUrl, setPlaybackUrl] = React.useState(
    initialValues.playbackUrl
  );
  const [channelStatus, setChannelStatus] = React.useState(
    initialValues.channelStatus
  );
  const [videoId, setVideoId] = React.useState(initialValues.videoId);
  const [createdAt, setCreatedAt] = React.useState(initialValues.createdAt);
  const [updatedAt, setUpdatedAt] = React.useState(initialValues.updatedAt);
  const [aliveToken, setAliveToken] = React.useState(initialValues.aliveToken);
  const [alivedAt, setAlivedAt] = React.useState(initialValues.alivedAt);
  const [errors, setErrors] = React.useState({});
  const resetStateValues = () => {
    const cleanValues = aWSChannelPoolRecord
      ? { ...initialValues, ...aWSChannelPoolRecord }
      : initialValues;
    setChannelId(cleanValues.channelId);
    setIngestServer(cleanValues.ingestServer);
    setStreamKey(cleanValues.streamKey);
    setInputId(cleanValues.inputId);
    setPlaybackUrl(cleanValues.playbackUrl);
    setChannelStatus(cleanValues.channelStatus);
    setVideoId(cleanValues.videoId);
    setCreatedAt(cleanValues.createdAt);
    setUpdatedAt(cleanValues.updatedAt);
    setAliveToken(cleanValues.aliveToken);
    setAlivedAt(cleanValues.alivedAt);
    setErrors({});
  };
  const [aWSChannelPoolRecord, setAWSChannelPoolRecord] = React.useState(
    aWSChannelPoolModelProp
  );
  React.useEffect(() => {
    const queryData = async () => {
      const record = idProp
        ? await DataStore.query(AWSChannelPool, idProp)
        : aWSChannelPoolModelProp;
      setAWSChannelPoolRecord(record);
    };
    queryData();
  }, [idProp, aWSChannelPoolModelProp]);
  React.useEffect(resetStateValues, [aWSChannelPoolRecord]);
  const validations = {
    channelId: [],
    ingestServer: [],
    streamKey: [],
    inputId: [],
    playbackUrl: [],
    channelStatus: [],
    videoId: [],
    createdAt: [],
    updatedAt: [],
    aliveToken: [],
    alivedAt: [],
  };
  const runValidationTasks = async (
    fieldName,
    currentValue,
    getDisplayValue
  ) => {
    const value =
      currentValue && getDisplayValue
        ? getDisplayValue(currentValue)
        : currentValue;
    let validationResponse = validateField(value, validations[fieldName]);
    const customValidator = fetchByPath(onValidate, fieldName);
    if (customValidator) {
      validationResponse = await customValidator(value, validationResponse);
    }
    setErrors((errors) => ({ ...errors, [fieldName]: validationResponse }));
    return validationResponse;
  };
  const convertTimeStampToDate = (ts) => {
    if (Math.abs(Date.now() - ts) < Math.abs(Date.now() - ts * 1000)) {
      return new Date(ts);
    }
    return new Date(ts * 1000);
  };
  const convertToLocal = (date) => {
    const df = new Intl.DateTimeFormat("default", {
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
      hour: "2-digit",
      minute: "2-digit",
      calendar: "iso8601",
      numberingSystem: "latn",
      hourCycle: "h23",
    });
    const parts = df.formatToParts(date).reduce((acc, part) => {
      acc[part.type] = part.value;
      return acc;
    }, {});
    return `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}`;
  };
  return (
    <Grid
      as="form"
      rowGap="15px"
      columnGap="15px"
      padding="20px"
      onSubmit={async (event) => {
        event.preventDefault();
        let modelFields = {
          channelId,
          ingestServer,
          streamKey,
          inputId,
          playbackUrl,
          channelStatus,
          videoId,
          createdAt,
          updatedAt,
          aliveToken,
          alivedAt,
        };
        const validationResponses = await Promise.all(
          Object.keys(validations).reduce((promises, fieldName) => {
            if (Array.isArray(modelFields[fieldName])) {
              promises.push(
                ...modelFields[fieldName].map((item) =>
                  runValidationTasks(fieldName, item)
                )
              );
              return promises;
            }
            promises.push(
              runValidationTasks(fieldName, modelFields[fieldName])
            );
            return promises;
          }, [])
        );
        if (validationResponses.some((r) => r.hasError)) {
          return;
        }
        if (onSubmit) {
          modelFields = onSubmit(modelFields);
        }
        try {
          Object.entries(modelFields).forEach(([key, value]) => {
            if (typeof value === "string" && value.trim() === "") {
              modelFields[key] = undefined;
            }
          });
          await DataStore.save(
            AWSChannelPool.copyOf(aWSChannelPoolRecord, (updated) => {
              Object.assign(updated, modelFields);
            })
          );
          if (onSuccess) {
            onSuccess(modelFields);
          }
        } catch (err) {
          if (onError) {
            onError(modelFields, err.message);
          }
        }
      }}
      {...getOverrideProps(overrides, "AWSChannelPoolUpdateForm")}
      {...rest}
    >
      <TextField
        label="Channel id"
        isRequired={false}
        isReadOnly={false}
        value={channelId}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId: value,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.channelId ?? value;
          }
          if (errors.channelId?.hasError) {
            runValidationTasks("channelId", value);
          }
          setChannelId(value);
        }}
        onBlur={() => runValidationTasks("channelId", channelId)}
        errorMessage={errors.channelId?.errorMessage}
        hasError={errors.channelId?.hasError}
        {...getOverrideProps(overrides, "channelId")}
      ></TextField>
      <TextField
        label="Ingest server"
        isRequired={false}
        isReadOnly={false}
        value={ingestServer}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer: value,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.ingestServer ?? value;
          }
          if (errors.ingestServer?.hasError) {
            runValidationTasks("ingestServer", value);
          }
          setIngestServer(value);
        }}
        onBlur={() => runValidationTasks("ingestServer", ingestServer)}
        errorMessage={errors.ingestServer?.errorMessage}
        hasError={errors.ingestServer?.hasError}
        {...getOverrideProps(overrides, "ingestServer")}
      ></TextField>
      <TextField
        label="Stream key"
        isRequired={false}
        isReadOnly={false}
        value={streamKey}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey: value,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.streamKey ?? value;
          }
          if (errors.streamKey?.hasError) {
            runValidationTasks("streamKey", value);
          }
          setStreamKey(value);
        }}
        onBlur={() => runValidationTasks("streamKey", streamKey)}
        errorMessage={errors.streamKey?.errorMessage}
        hasError={errors.streamKey?.hasError}
        {...getOverrideProps(overrides, "streamKey")}
      ></TextField>
      <TextField
        label="Input id"
        isRequired={false}
        isReadOnly={false}
        value={inputId}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId: value,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.inputId ?? value;
          }
          if (errors.inputId?.hasError) {
            runValidationTasks("inputId", value);
          }
          setInputId(value);
        }}
        onBlur={() => runValidationTasks("inputId", inputId)}
        errorMessage={errors.inputId?.errorMessage}
        hasError={errors.inputId?.hasError}
        {...getOverrideProps(overrides, "inputId")}
      ></TextField>
      <TextField
        label="Playback url"
        isRequired={false}
        isReadOnly={false}
        value={playbackUrl}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl: value,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.playbackUrl ?? value;
          }
          if (errors.playbackUrl?.hasError) {
            runValidationTasks("playbackUrl", value);
          }
          setPlaybackUrl(value);
        }}
        onBlur={() => runValidationTasks("playbackUrl", playbackUrl)}
        errorMessage={errors.playbackUrl?.errorMessage}
        hasError={errors.playbackUrl?.hasError}
        {...getOverrideProps(overrides, "playbackUrl")}
      ></TextField>
      <TextField
        label="Channel status"
        isRequired={false}
        isReadOnly={false}
        value={channelStatus}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus: value,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.channelStatus ?? value;
          }
          if (errors.channelStatus?.hasError) {
            runValidationTasks("channelStatus", value);
          }
          setChannelStatus(value);
        }}
        onBlur={() => runValidationTasks("channelStatus", channelStatus)}
        errorMessage={errors.channelStatus?.errorMessage}
        hasError={errors.channelStatus?.hasError}
        {...getOverrideProps(overrides, "channelStatus")}
      ></TextField>
      <TextField
        label="Video id"
        isRequired={false}
        isReadOnly={false}
        value={videoId}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId: value,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.videoId ?? value;
          }
          if (errors.videoId?.hasError) {
            runValidationTasks("videoId", value);
          }
          setVideoId(value);
        }}
        onBlur={() => runValidationTasks("videoId", videoId)}
        errorMessage={errors.videoId?.errorMessage}
        hasError={errors.videoId?.hasError}
        {...getOverrideProps(overrides, "videoId")}
      ></TextField>
      <TextField
        label="Created at"
        isRequired={false}
        isReadOnly={false}
        type="datetime-local"
        value={createdAt && convertToLocal(new Date(createdAt))}
        onChange={(e) => {
          let value =
            e.target.value === "" ? "" : new Date(e.target.value).toISOString();
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt: value,
              updatedAt,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.createdAt ?? value;
          }
          if (errors.createdAt?.hasError) {
            runValidationTasks("createdAt", value);
          }
          setCreatedAt(value);
        }}
        onBlur={() => runValidationTasks("createdAt", createdAt)}
        errorMessage={errors.createdAt?.errorMessage}
        hasError={errors.createdAt?.hasError}
        {...getOverrideProps(overrides, "createdAt")}
      ></TextField>
      <TextField
        label="Updated at"
        isRequired={false}
        isReadOnly={false}
        type="datetime-local"
        value={updatedAt && convertToLocal(new Date(updatedAt))}
        onChange={(e) => {
          let value =
            e.target.value === "" ? "" : new Date(e.target.value).toISOString();
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt: value,
              aliveToken,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.updatedAt ?? value;
          }
          if (errors.updatedAt?.hasError) {
            runValidationTasks("updatedAt", value);
          }
          setUpdatedAt(value);
        }}
        onBlur={() => runValidationTasks("updatedAt", updatedAt)}
        errorMessage={errors.updatedAt?.errorMessage}
        hasError={errors.updatedAt?.hasError}
        {...getOverrideProps(overrides, "updatedAt")}
      ></TextField>
      <TextField
        label="Alive token"
        isRequired={false}
        isReadOnly={false}
        value={aliveToken}
        onChange={(e) => {
          let { value } = e.target;
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken: value,
              alivedAt,
            };
            const result = onChange(modelFields);
            value = result?.aliveToken ?? value;
          }
          if (errors.aliveToken?.hasError) {
            runValidationTasks("aliveToken", value);
          }
          setAliveToken(value);
        }}
        onBlur={() => runValidationTasks("aliveToken", aliveToken)}
        errorMessage={errors.aliveToken?.errorMessage}
        hasError={errors.aliveToken?.hasError}
        {...getOverrideProps(overrides, "aliveToken")}
      ></TextField>
      <TextField
        label="Alived at"
        isRequired={false}
        isReadOnly={false}
        type="datetime-local"
        value={alivedAt && convertToLocal(convertTimeStampToDate(alivedAt))}
        onChange={(e) => {
          let value =
            e.target.value === "" ? "" : Number(new Date(e.target.value));
          if (onChange) {
            const modelFields = {
              channelId,
              ingestServer,
              streamKey,
              inputId,
              playbackUrl,
              channelStatus,
              videoId,
              createdAt,
              updatedAt,
              aliveToken,
              alivedAt: value,
            };
            const result = onChange(modelFields);
            value = result?.alivedAt ?? value;
          }
          if (errors.alivedAt?.hasError) {
            runValidationTasks("alivedAt", value);
          }
          setAlivedAt(value);
        }}
        onBlur={() => runValidationTasks("alivedAt", alivedAt)}
        errorMessage={errors.alivedAt?.errorMessage}
        hasError={errors.alivedAt?.hasError}
        {...getOverrideProps(overrides, "alivedAt")}
      ></TextField>
      <Flex
        justifyContent="space-between"
        {...getOverrideProps(overrides, "CTAFlex")}
      >
        <Button
          children="Reset"
          type="reset"
          onClick={(event) => {
            event.preventDefault();
            resetStateValues();
          }}
          isDisabled={!(idProp || aWSChannelPoolModelProp)}
          {...getOverrideProps(overrides, "ResetButton")}
        ></Button>
        <Flex
          gap="15px"
          {...getOverrideProps(overrides, "RightAlignCTASubFlex")}
        >
          <Button
            children="Submit"
            type="submit"
            variation="primary"
            isDisabled={
              !(idProp || aWSChannelPoolModelProp) ||
              Object.values(errors).some((e) => e?.hasError)
            }
            {...getOverrideProps(overrides, "SubmitButton")}
          ></Button>
        </Flex>
      </Flex>
    </Grid>
  );
}