'use client';

import { useEffect, useState, createContext, useContext } from 'react';
import { Context, miniAppHost } from '@farcaster/miniapp-sdk';
import { useLoginToFrame } from '@privy-io/react-auth/farcaster';
import { usePrivy, useWallets } from '@privy-io/react-auth';
import { useIsMiniAppOnMobile } from '@/lib/hooks/useIsMiniAppOnMobile';
import { useAccount, useConnect } from 'wagmi';
import { farcasterMiniApp } from '@farcaster/miniapp-wagmi-connector';
import { CLIENT_FIDS } from '@/lib/constants/common';

const MiniAppContext = createContext<{
  isSDKLoaded: boolean;
  miniAppContext: Context.MiniAppContext | null;
  loginIntoMiniApp: () => Promise<void>;
  miniAppEnv: 'farcaster' | 'coinbase_wallet' | null;
}>({
  isSDKLoaded: false,
  miniAppContext: null,
  loginIntoMiniApp: () => Promise.resolve(),
  miniAppEnv: null,
});

export const useMiniAppContext = () => {
  const context = useContext(MiniAppContext);
  if (!context) {
    throw new Error('useMiniApp must be used within a MiniAppProvider');
  }
  return context;
};

export default function MiniAppProvider({
  children,
}: {
  children: React.ReactNode;
}) {
  const [isSDKLoaded, setIsSDKLoaded] = useState(false);
  const [miniAppContext, setMiniAppContext] =
    useState<Context.MiniAppContext | null>(null);

  const { ready, authenticated, user } = usePrivy();
  const { initLoginToFrame, loginToFrame } = useLoginToFrame();
  const isMiniAppOnMobile = useIsMiniAppOnMobile();
  const { connect } = useConnect();
  const { wallets } = useWallets();

  const [miniAppEnv, setMiniAppEnv] = useState<
    'farcaster' | 'coinbase_wallet' | null
  >(null);
  const { isConnected } = useAccount();

  // Setup SDK
  useEffect(() => {
    const load = async () => {
      const miniAppContext = await miniAppHost.context;
      // await setTimeout(10000);

      await miniAppHost.ready();
      setMiniAppContext(miniAppContext);

      setMiniAppEnv(
        miniAppContext.client.clientFid === CLIENT_FIDS.FARCASTER
          ? 'farcaster'
          : 'coinbase_wallet',
      );
    };

    if (miniAppHost && !isSDKLoaded) {
      setIsSDKLoaded(true);
      load();
    }
  }, [isSDKLoaded]);

  const login = async () => {
    const { nonce } = await initLoginToFrame();
    const result = await miniAppHost.signIn({
      nonce,
      acceptAuthAddress: true,
    });

    if (result.result?.message && result.result?.signature) {
      await loginToFrame({
        message: result.result.message,
        signature: result.result.signature,
      });
    }
  };

  // Add MiniApp
  useEffect(() => {
    if (!miniAppContext || !authenticated) {
      return;
    }

    const addMiniApp = async () => {
      await miniAppHost.addMiniApp();
    };

    if (!miniAppContext?.client.added) {
      setTimeout(() => {
        addMiniApp();
      }, 1000);
    }
  }, [miniAppContext, authenticated, ready, user]);

  // If we are on mobile and have miniApp context, connect to farcaster wallet
  useEffect(() => {
    if (isConnected) {
      return;
    }

    if (miniAppContext && isMiniAppOnMobile) {
      connect({ connector: farcasterMiniApp() });
    }
  }, [miniAppContext, isMiniAppOnMobile, isConnected, wallets]);

  return (
    <MiniAppContext.Provider
      value={{
        isSDKLoaded,
        miniAppContext,
        loginIntoMiniApp: login,
        miniAppEnv,
      }}
    >
      {children}
    </MiniAppContext.Provider>
  );
}