/* eslint-disable @typescript-eslint/no-explicit-any */
import type { UserData } from '../App';
import { getPlatformConfig } from './config';

declare global {
  interface Window {
    liff: any;
  }
}

export const lineLogin = async (): Promise<UserData> => {
  const config = getPlatformConfig('line');
  if (!config.enabled || !config.key) {
    throw new Error('LINE is not configured or disabled');
  }

  return new Promise((resolve, reject) => {
    const width = 600;
    const height = 700;
    const left = window.screenX + (window.outerWidth - width) / 2;
    const top = window.screenY + (window.outerHeight - height) / 2;

    const redirectUri = window.location.origin + '/apps/auth/callback?shop=${window.location.origin}&platform=line';
    console.log('LINEログイン - リダイレクトURL:', redirectUri);

    const authUrl = `https://access.line.me/oauth2/v2.1/authorize?` +
      `response_type=code&` +
      `client_id=${config.key}&` +
      `redirect_uri=${encodeURIComponent(redirectUri)}&` +
      `state=${window.crypto.randomUUID()}&` +
      `scope=profile%20openid%20email`;

    const authWindow = window.open(
      authUrl,
      'lineLogin',
      `width=${width},height=${height},left=${left},top=${top}`
    );

    const handleMessage = async (event: MessageEvent) => {
      if (event.origin !== window.location.origin) return;
      
      const { code, error } = event.data || {};
      
      window.removeEventListener('message', handleMessage);
      authWindow?.close();

      if (error) {
        reject(new Error(error));
        return;
      }

      if (code) {
        try {
          // トークンを取得
          const tokenResponse = await fetch('https://api.line.me/oauth2/v2.1/token', {
            method: 'POST',
            headers: {
              'Content-Type': 'application/x-www-form-urlencoded',
            },
            body: new URLSearchParams({
              grant_type: 'authorization_code',
              code: code,
              redirect_uri: redirectUri,
              client_id: config.key,
              client_secret: config.secret || '',
            }).toString(),
          });

          if (!tokenResponse.ok) {
            const errorData = await tokenResponse.json();
            console.error('LINE token error:', errorData);
            throw new Error(`Token request failed: ${errorData.error_description || errorData.error || 'Unknown error'}`);
          }

          const tokenData = await tokenResponse.json();
          
          if (tokenData.error) {
            console.error('LINE token response error:', tokenData);
            throw new Error(tokenData.error_description || tokenData.error);
          }

          // ユーザー情報を取得
          const userInfoResponse = await fetch('https://api.line.me/v2/profile', {
            headers: {
              Authorization: `Bearer ${tokenData.access_token}`,
            },
          });

          if (!userInfoResponse.ok) {
            const errorData = await userInfoResponse.json();
            console.error('LINE profile error:', errorData);
            throw new Error(`Profile request failed: ${errorData.message || 'Unknown error'}`);
          }

          const userInfo = await userInfoResponse.json();

          // IDトークンからメールアドレスを取得
          let email = '';
          if (tokenData.id_token) {
            try {
              const idTokenPayload = JSON.parse(atob(tokenData.id_token.split('.')[1]));
              email = idTokenPayload.email || '';
            } catch (e) {
              console.warn('Failed to decode ID token:', e);
            }
          }

          const userData: UserData = {
            name: userInfo.displayName || '',
            email: email,
            birthday: '',
            profileImage: userInfo.pictureUrl || '',
            platform: 'line',
            accessToken: tokenData.access_token,
            response: tokenData
          };

          resolve(userData);
        } catch (err) {
          reject(err);
        }
      } else {
        reject(new Error('LINE login failed'));
      }
    };

    window.addEventListener('message', handleMessage);

    // ウィンドウが閉じられた場合の処理
    const checkClosed = setInterval(() => {
      if (authWindow?.closed) {
        clearInterval(checkClosed);
        window.removeEventListener('message', handleMessage);
        reject(new Error('User closed the authentication window'));
      }
    }, 1000);
  });
};

export default lineLogin;