import { Web3Provider } from '@ethersproject/providers';
import {
  AndCondition,
  OrCondition,
  FollowCondition,
  CollectCondition,
  EncryptedMetadata,
  EoaOwnership,
  Erc20TokenOwnership,
  MetadataV2,
  NftOwnership,
  ProfileOwnership,
  PublicationMainFocus,
  ContractType,
  ScalarOperator,
  LensGatedSDK,
  LensEnvironment,
} from '@lens-protocol/sdk-gated';

let metadata: MetadataV2 = {
  version: '2.0.0',
  name: 'name',
  description: 'description',
  attributes: [],
  content: 'content',
  metadata_id: '1',
  appId: 'app_id',
  mainContentFocus: PublicationMainFocus.TextOnly,
  locale: 'en',
};

const uploadMetadataHandler = async (data: EncryptedMetadata): Promise<string> => {
  // Upload the encrypted metadata to your server and return a publicly accessible url
  return Promise.resolve('test');
};

const nftAccessCondition: NftOwnership = {
  contractAddress: '0x0000000000000000000000000000000000000000', // the address of the NFT collection, make sure it is a valid address depending on the chosen network
  chainID: 80001, // the chain ID of the network the NFT collection is deployed on;
  contractType: ContractType.Erc721, // the type of the NFT collection, ERC721 and ERC1155 are supported
  tokenIds: ['1', '2', '3'], // OPTIONAL - the token IDs of the NFTs that grant access to the metadata, if ommitted, owning any NFT from the collection will grant access
};

const eoaAccessCondition: EoaOwnership = {
  address: '0x0000000000000000000000000000000000000000', // the address of the EOA that grants access to the metadata
  chainID: 80001, // the chain ID of the network
};

const erc20AccessCondition: Erc20TokenOwnership = {
  contractAddress: '0x0000000000000000000000000000000000000000', // the address of the ERC20 token that signers should own
  chainID: 80001, // the chain ID of the network
  amount: '1000000000000000000', // the amount of the ERC20 token that grants access to the metadata
  decimals: 18, // the decimals of the ERC20 token that grants access to the metadata
  condition: ScalarOperator.GreaterThanOrEqual, // the condition that must be met to grant access to the metadata, supported conditions are: '==', '!=', '>', '<', '>=', '<='
};

const profileAccessCondition: ProfileOwnership = {
  profileId: '0x01',
};

const followAccessCondition: FollowCondition = {
  profileId: '0x01',
};

const collectAccessCondition: CollectCondition = {
  publicationId: '0x01-0x01',
};

const andCondition: AndCondition = {
  criteria: [
    {
      token: erc20AccessCondition,
    },
    {
      follow: followAccessCondition,
    },
  ],
};

const orCondition: OrCondition = {
  criteria: [
    {
      collect: collectAccessCondition,
    },
    {
      profile: profileAccessCondition,
    },
  ],
}(async () => {
  const sdk = await LensGatedSDK.create({
    provider: new Web3Provider(window.ethereum), // or any ethers Provider
    signer: signer, // a wallet or JsonRpcSigner from wagmi or similar
    env: LensEnvironment.Mumbai,
  });

  // this must be called anytime you change networks, exposed so you can add this to your Web3Provider event handling
  // but not necessary to call explicitly
  await sdk.connect({
    address: '0x1234123412341234123412341234123412341234', // your signer's wallet address
    env: LensEnvironment.Polygon,
  });

  const { error, contentURI, encryptedMetadata } = await sdk.gated.encryptMetadata(
    metadata,
    '0x01', // the signed in user's profile id
    {
      nft: nftAccessCondition,
    }, // or any other access condition object
    uploadMetadataHandler
  );
  console.log(contentURI);
  // contentURI is ready to be used in the `contentURI` field of your `createPostTypedMetadata` call
  // also exposing the encrypted metadata in case you want to do something with it
  // ... create post using the Lens API ...

  // decrypt metadata
  // in most usecases you will fetch the metadata from the Lens API `getPublications` or similar call that returns
  // publication content,then for content with `isGated` = true, you can apply the decryption function to the
  // publication's metadata object
  const { decrypted } = await sdk.gated.decryptMetadata(encryptedMetadata);

  // deinitializes variables and deletes the SIWE-compatible signature from storage
  await sdk.disconnect();
})();