import express from 'express';
import { DhanHqClient, DhanEnv } from 'dhan-ts';

const app = express();
const API_KEY = process.env.DHAN_API_KEY!;
const API_SECRET = process.env.DHAN_API_SECRET!;
const CLIENT_ID = process.env.DHAN_CLIENT_ID!;

const client = new DhanHqClient({
  accessToken: '',
  clientId: CLIENT_ID,
  env: DhanEnv.PROD,
});

// Store tokens in memory (use database in production)
const tokens = new Map<string, string>();

// Initiate authentication
app.get('/auth/login', async (req, res) => {
  try {
    const consent = await client.authentication.generateConsentApp(
      API_KEY,
      API_SECRET,
      CLIENT_ID
    );

    const loginUrl = `https://auth.dhan.co/app/login?consentAppId=${consent.consentAppId}`;
    res.redirect(loginUrl);
  } catch (error) {
    res.status(500).json({ error: 'Authentication failed' });
  }
});

// Handle callback
app.get('/auth/callback', async (req, res) => {
  const { tokenId } = req.query;

  if (!tokenId) {
    return res.status(400).json({ error: 'Missing tokenId' });
  }

  try {
    const authData = await client.authentication.consumeConsentApp(
      API_KEY,
      API_SECRET,
      tokenId as string
    );

    // Store the access token
    tokens.set(authData.dhanClientId, authData.accessToken);

    res.json({
      message: 'Authentication successful',
      clientId: authData.dhanClientId,
      clientName: authData.dhanClientName,
      expiryTime: authData.expiryTime,
    });
  } catch (error) {
    res.status(500).json({ error: 'Failed to consume consent' });
  }
});

// Use authenticated client
app.get('/api/orders', async (req, res) => {
  const clientId = req.headers['x-client-id'] as string;
  const accessToken = tokens.get(clientId);

  if (!accessToken) {
    return res.status(401).json({ error: 'Not authenticated' });
  }

  const authenticatedClient = new DhanHqClient({
    accessToken,
    clientId,
    env: DhanEnv.PROD,
  });

  try {
    const orders = await authenticatedClient.orders.getOrders();
    res.json(orders);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch orders' });
  }
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

// app/api/auth/login/route.ts
import { DhanHqClient, DhanEnv } from 'dhan-ts';
import { NextResponse } from 'next/server';

const client = new DhanHqClient({
  accessToken: '',
  clientId: process.env.DHAN_CLIENT_ID!,
  env: DhanEnv.PROD,
});

export async function GET() {
  try {
    const consent = await client.authentication.generateConsentApp(
      process.env.DHAN_API_KEY!,
      process.env.DHAN_API_SECRET!,
      process.env.DHAN_CLIENT_ID!
    );

    const loginUrl = `https://auth.dhan.co/app/login?consentAppId=${consent.consentAppId}`;
    return NextResponse.redirect(loginUrl);
  } catch (error) {
    return NextResponse.json(
      { error: 'Authentication failed' },
      { status: 500 }
    );
  }
}

// app/api/auth/callback/route.ts
export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const tokenId = searchParams.get('tokenId');

  if (!tokenId) {
    return NextResponse.json(
      { error: 'Missing tokenId' },
      { status: 400 }
    );
  }

  try {
    const authData = await client.authentication.consumeConsentApp(
      process.env.DHAN_API_KEY!,
      process.env.DHAN_API_SECRET!,
      tokenId
    );

    // Store in session/database
    // For example, using cookies:
    const response = NextResponse.json({
      message: 'Authentication successful',
      clientId: authData.dhanClientId,
    });

    response.cookies.set('dhan_access_token', authData.accessToken, {
      httpOnly: true,
      secure: true,
      maxAge: 86400, // 24 hours
    });

    return response;
  } catch (error) {
    return NextResponse.json(
      { error: 'Failed to consume consent' },
      { status: 500 }
    );
  }
}