import { StorefrontShopAdapterLocal } from '@makaira/storefront-shop-adapter-local'

const client = new StorefrontShopAdapterLocal()

import { UserLoginEvent } from '@makaira/storefront-types'

function setUser({ data: { data, raw } }) {}

client.addEventListener(UserLoginEvent.eventName, setUser)

import { StorefrontShopAdapterLocal } from '@makaira/storefront-shop-adapter-local'

const client = new StorefrontShopAdapterLocal()

const { data, error, raw } = await client.user.login({
  input: { username: 'foo', password: 'bar' },
})

const cart = await client.cart.getCart({ input: {} })

const { data, error, raw } = cart

const result = await client.cart.addItem({
  input: {
    id: 'foo',
    quantity: 1,
    attributes: [
      {
        key: 'foo',
        value: 'bar',
      },
    ],
  },
})

const { data, error, raw } = result

import { CartAddItemEvent } from '@makaira/storefront-types'

function setNewCart({ data: { data, raw } }) {}

client.addEventListener(CartAddItemEvent.eventName, setNewCart)

const result = await client.cart.updateItem({
  input: {
    id: 'foo',
    quantity: 2,
    attributes: [
      {
        key: 'foo',
        value: 'bar',
      },
    ],
  },
})

const { data, error, raw } = result

import { CartUpdateItemEvent } from '@makaira/storefront-types'

function setNewCart({ data: { data, raw } }) {}

client.addEventListener(CartUpdateItemEvent.eventName, setNewCart)

const result = await client.cart.removeItem({ input: { id: 'foo' } })

const { data, error, raw } = result

import { CartRemoveItemEvent } from '@makaira/storefront-types'

function setNewCart({ data: { data, raw } }) {}

client.addEventListener(CartRemoveItemEvent.eventName, setNewCart)

const reviews = await client.review.getReviews({
  input: { product: { id: 'foo' }, pagination: { limit: 10, offset: 0 } },
})

const { data, error, raw } = reviews

const result = await client.review.createReview({
  input: {
    review: {
      rating: 2,
      text: 'foo bar',
      product: {
        id: 'foo',
      },
    },
  },
})

const { data, error, raw } = result

import { ReviewCreateEvent } from '@makaira/storefront-types'

function setNewReview({ data: { data, raw } }) {}

client.addEventListener(ReviewCreateEvent.eventName, setNewReview)

const user = await client.user.getUser({ input: {} })

const { data, error, raw } = user

const result = await client.user.login({
  input: {
    username: 'foo',
    password: 'bar',
  },
})

const { data, error, raw } = result

import { UserLoginEvent } from '@makaira/storefront-types'

function setUser({ data: { data, raw } }) {}

client.addEventListener(UserLoginEvent.eventName, setUser)

const result = await client.user.signup({
  input: {
    username: 'foo',
    password: 'bar',
  },
})

const { data, error, raw } = result

import { UserSignupEvent } from '@makaira/storefront-types'

function setUser({ data: { data, raw } }) {}

client.addEventListener(UserSignupEvent.eventName, setUser)

const result = await client.user.forgotPassword({
  input: {
    username: 'foo',
  },
})

const { data, error, raw } = result

const result = await client.user.logout({
  input: {},
})

const { data, error, raw } = result

import { UserLogoutEvent } from '@makaira/storefront-types'

function setUser({ data: { data, raw } }) {}

client.addEventListener(UserLogoutEvent.eventName, setUser)

const wishlist = await client.wishlist.getWishlist({ input: {} })

const { data, error, raw } = wishlist

const result = await client.wishlist.addItem({
  input: {
    id: 'foo',
    attributes: [
      {
        key: 'foo',
        value: 'bar',
      },
    ],
  },
})

const { data, error, raw } = result

import { WishlistAddItemEvent } from '@makaira/storefront-types'

function setNewWishlist({ data: { data, raw } }) {}

client.addEventListener(WishlistAddItemEvent.eventName, setNewWishlist)

const result = await client.wishlist.removeItem({ input: { id: 'foo' } })

const { data, error, raw } = result

import { WishlistRemoveItemEvent } from '@makaira/storefront-types'

function setNewWishlist({ data: { data, raw } }) {}

client.addEventListener(WishlistRemoveItemEvent.eventName, setNewWishlist)

import { StorefrontShopAdapterLocal } from '@makaira/storefront-shop-adapter-local'

const client = new StorefrontShopAdapterLocal()

import {
  StorefrontShopAdapterLocalUser,
  StorefrontShopAdapterLocal,
  StorefrontShopAdapterLocalCart,
  StorefrontShopAdapterLocalCheckout,
  StorefrontShopAdapterLocalWishlist,
  StorefrontShopAdapterLocalReview,
} from '@makaira/storefront-shop-adapter-local'
import {
  MakairaShopProviderUser,
  MakairaShopProviderInteractor,
  MakairaLogout,
} from '@makaira/storefront-types'

class CustomUserProvider
  extends StorefrontShopAdapterLocalUser
  implements MakairaShopProviderUser
{
  // This is required because super only works on prototype members.
  // Look for more details here: https://basarat.gitbook.io/typescript/future-javascript/arrow-functions#tip-arrow-functions-and-inheritance
  private superLogout = this.logout

  constructor(mainAdapter: StorefrontShopAdapterLocal) {
    super(mainAdapter)
  }

  // We recommend you to use our base signature for each method.
  // When you use typescript you can safely archive this:
  setUserDisplayName: MakairaShopProviderInteractor<
    { inputVariable1: string },
    { returnedVariable1: string },
    { returnedRawVariable1: string },
    Error
  > = async ({ input: { inputVariable1 } }) => {
    return {
      raw: { returnedRawVariable1: inputVariable1 },
      data: { returnedVariable1: inputVariable1 },
      error: undefined,
    }

    // or with error
    return {
      raw: { returnedRawVariable1: inputVariable1 },
      data: undefined,
      error: new Error('some error'),
    }
  }

  // if you don't prefer using our base method signature define it yourself
  setUserDisplayName(inputVariable1: string) {
    return inputVariable1
  }

  // you can even overwrite existing methods
  logout: MakairaLogout<
    { additionalInput1: string },
    { customRawData1: string }
  > = async ({ input: { additionalInput1 } }) => {
    // The super only works on prototype members. Therefore we need to create a copy.
    // Look for more details here: https://basarat.gitbook.io/typescript/future-javascript/arrow-functions#tip-arrow-functions-and-inheritance
    const response = await this.superLogout({ input: {} })

    return {
      data: response.data,
      raw: { customRawData1: additionalInput1 },
      error: response.error,
    }
  }
}

const client = new StorefrontShopAdapterLocal<
  StorefrontShopAdapterLocalCart,
  StorefrontShopAdapterLocalCheckout,
  CustomUserProvider,
  StorefrontShopAdapterLocalWishlist,
  StorefrontShopAdapterLocalReview
>({
  providers: {
    user: CustomUserProvider,
  },
})

export type MakairaResponse<ResData, ResRawData, ResError extends Error> = {
  data?: ResData // The response data property which the feature method returns. Can be undefined in a case of error or when no data has to be returned.
  raw: ResRawData // the response raw property which the feature method returns. Is by required but you can set it to undefined if you wish.
  error?: ResError // The type of error that could be returned. Currently each feature method uses an instance of Error.
}

export type MakairaShopProviderInteractorContext<Input> = {
  input: Input // The input data which the feature method receives.
}

export type MakairaShopProviderInteractor<
  Input = unknown, // The input data which the feature method receives.
  ResData = unknown, // The response data property which the feature method returns. Can be undefined in a case of error or when no data has to be returned.
  ResRawData = unknown, // the response raw property which the feature method returns. Is by required but you can set it to undefined if you wish.
  ResError extends Error = Error // The type of error that could be returned. Currently each feature method uses an instance of Error.
> = (
  context: MakairaShopProviderInteractorContext<Input>
) => Promise<MakairaResponse<ResData, ResRawData, ResError>>

// Defining a feature method without input arguments.

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  foo: MakairaShopProviderInteractor<
    unknown, // To disable any input arguments set here to unknown
    { dataResponseVariable1: string },
    { rawResponseVariable1: string },
    Error
  > = async () => {}
}

// Defining a feature method without return data or raw response.

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  foo: MakairaShopProviderInteractor<
    {inputVariable1:string}
    undefined, // Set this to undefined to have a response data property without data. The data and the raw property can be set independently to undefined.
    undefined, // Set this to undefined to have a response raw property without data. The data and the raw property can be set independently to undefined.
    Error
  > = async () => {}
}

// Adjust the returned type of the error.

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  foo: MakairaShopProviderInteractor<
    unknown,
    { dataResponseVariable1: string },
    { rawResponseVariable1: string },
    NotImplementedError // Adjust this to set a custom error type.
  > = async () => {}
}

// You can create a new type of it that is again generic. This is used when you add new feature methods for all shop adapters. Here is the example of the login

export type MakairaLoginInput<AdditionalInput = unknown> = {
  username: string
  password: string
} & AdditionalInput

export type MakairaLoginResData = {
  user: MakairaUser
}

export type MakairaLogin<
  AdditionalInput = any,
  ResRawData = any,
  ResError extends Error = Error
> = MakairaShopProviderInteractor<
  MakairaLoginInput<AdditionalInput>,
  MakairaLoginResData,
  ResRawData,
  ResError
>

export type LocalLoginRaw = { rawResponseVariable1: string }

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  login: MakairaLogin<unknown, LocalLoginRaw, Error> = async ({
    input: { inputVariable1 },
  }) => {
    if (inputVariable1 !== 'foo') {
      return {
        data: undefined,
        raw: { rawResponseVariable1: inputVariable1 },
        error: new Error('inputVariable1 does not match foot'),
      }
    }

    return {
      data: { dataResponseVariable1: inputVariable1 },
      raw: { rawResponseVariable1: inputVariable1 },
      error: undefined,
    }
  }
}

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  foo: MakairaShopProviderInteractor<
    { inputVariable1: string },
    { dataResponseVariable1: string },
    { rawResponseVariable1: string },
    Error
  > = async ({ input: { inputVariable1 } }) => {
    if (inputVariable1 !== 'foo') {
      return {
        data: undefined,
        raw: { rawResponseVariable1: inputVariable1 },
        error: new Error('inputVariable1 does not match foot'),
      }
    }

    return {
      data: { dataResponseVariable1: inputVariable1 },
      raw: { rawResponseVariable1: inputVariable1 },
      error: undefined,
    }
  }
}

//#region type definition: deleteUser

// To have a better separation and a better reading we first create the input type. These are the input arguments that each shop adapter has to support. By the generic AdditionalInput it is possible to add more shop provider specific input arguments.

export type MakairaDeleteUserInput<AdditionalInput = unknown> = {
  username: string
} & AdditionalInput

// As an alternative where you don't need any basic input arguments you can also write the following:

export type MakairaDeleteUserInput<AdditionalInput = unknown> = AdditionalInput

// Next we define the unified response data. In the case of deleteUser we don't have any response data.
export type MakairaDeleteUserResData = undefined

// If you have any response data you can write the following:
export type MakairaDeleteUserResData = { resDataVariable1: boolean }

// And finally we have to combine everything using the MakairaShopProviderInteractor into a new generic type. This new type is again generic to allow each shop adapter to define it's own additional input arguments and their custom response raw data.
export type MakairaDeleteUser<
  AdditionalInput = any,
  ResRawData = any,
  ResError extends Error = Error
> = MakairaShopProviderInteractor<
  MakairaDeleteUserInput<AdditionalInput>,
  MakairaDeleteUserResData,
  ResRawData,
  ResError
>
//#endregion

export type MakairaShopProviderUser = {
  login: MakairaLogin
  // ...
  // ...
  deleteUser: MakairaDeleteUser
}

export class StorefrontShopAdapterLocalUser implements MakairaShopProviderUser {
  constructor(private mainAdapter: StorefrontShopAdapterLocal) {}

  // Example 1: base usage without additional input variables and without raw data
  deleteUser: MakairaDeleteUser<unknown, undefined, Error> = async ({
    input: {},
  }) => {
    // your specific implementation ...
  }

  // Example 2: base usage with additional input variables and without raw data
  deleteUser: MakairaDeleteUser<{ confirm: boolean }, undefined, Error> =
    async ({ input: { confirm } }) => {
      // your specific implementation ...
    }

  // Example 3: base usage with additional input variables and with raw data
  deleteUser: MakairaDeleteUser<
    { confirm: boolean },
    { successful: boolean },
    Error
  > = async ({ input: { confirm } }) => {
    // your specific implementation ...
  }
}

import { MakairaShopProviderInteractor } from '../general/shop-provider-interactor'

//#region type definition: getOrders
export type MakairaGetOrdersInput<AdditionalInput = unknown> = {
  user: { id: string }
} & AdditionalInput

export type MakairaGetOrdersResData = {
  orders: { id: string; products: MakairaProduct[] }
}

export type MakairaGetOrders<
  AdditionalInput = any,
  ResRawData = any,
  ResError extends Error = Error
> = MakairaShopProviderInteractor<
  MakairaGetOrdersInput<AdditionalInput>,
  MakairaGetOrdersResData,
  ResRawData,
  ResError
>
//#endregion

//#region type definition: provider order
export type MakairaShopProviderOrder = {
  getOrders: MakairaGetOrders
}

export type MakairaShopProviderOptions<
  CartProviderType = MakairaShopProviderCart,
  // ... other features/providers defined
  // ...
  OrderProviderType = MakairaShopProviderOrder, // <- add this here
  AdditionalOptions = unknown
> = {
  providers?: {
    cart?: Constructor<CartProviderType>
    // ... other features/providers defined
    // ...
    order?: Constructor<OrderProviderType> // <- add this here
  }
} & AdditionalOptions

export interface MakairaShopProvider<
  CartProviderType extends MakairaShopProviderCart = MakairaShopProviderCart,
  // ... other features/providers defined
  // ...
  OrderProviderType extends MakairaShopProviderOrder = MakairaShopProviderOrder // <- add this here
> extends EventTarget {
  cart: CartProviderType

  // ... other features/providers defined
  // ...

  order: OrderProviderType // <- add this here
}

import { StorefrontShopAdapterLocal } from './main'

export class StorefrontShopAdapterLocalOrder
  implements MakairaShopProviderOrder
{
  constructor(private mainAdapter: StorefrontShopAdapterLocal) {}

  // ... shop adapter specific feature method implementations
}

export class StorefrontShopAdapterLocal<
    CartProviderType extends MakairaShopProviderCart = StorefrontShopAdapterLocalCart,
    // ... other features/providers defined
    // ...
    OrderProviderType extends MakairaShopProviderOrder = StorefrontShopAdapterLocalOrder // <- add this here
  >
  extends EventTarget
  implements
    MakairaShopProvider<
      CartProviderType,
      // ... other features/providers defined
      // ...
      OrderProviderType // <- add this here
    >
{
  cart: CartProviderType

  // ... other features/providers defined
  // ...

  order: OrderProviderType // <- add this here

  constructor(
    options: MakairaShopProviderOptions<
      CartProviderType,
      // ... other features/providers defined
      // ...
      OrderProviderType // <- add this here
    > = {}
  ) {
    super()

    // Here are all other providers to destructed.
    // Because of our goal to make everything customizable as much as possible we assign here a default value instead of directly initializing our new created feature. So in the future feature overwriting by passing a custom provider is possible.
    const {
      cart: CartProvider = StorefrontShopAdapterLocalCart,
      // ... other features/providers defined
      // ...
      order: OrderProvider = StorefrontShopAdapterLocalOrder, // <- add this here
    } = options.providers ?? {}

    // @ts-expect-error https://stackoverflow.com/questions/56505560/how-to-fix-ts2322-could-be-instantiated-with-a-different-subtype-of-constraint
    this.cart = new CartProvider(this)

    // ... other features/providers defined
    // ...

    // @ts-expect-error https://stackoverflow.com/questions/56505560/how-to-fix-ts2322-could-be-instantiated-with-a-different-subtype-of-constraint
    this.order = new OrderProvider(this) // <- add this here
  }
}

class StorefrontShopAdapterDemo {
  constructor(
    options: MakairaShopProviderOptions<
      CartProviderType,
      CheckoutProviderType,
      UserProviderType,
      WishlistProviderType,
      ReviewProviderType,
      { apiUrl: string } // <-- add this here
    >
  ) {
    super()

    // custom code
    // ...
  }
}