// pages/api/blueauth.js

import { handler as blueauthHandler } from 'blueauth/nextjs';

// In this example our users are in this array,
// but in the real world you likely have them stored
// in an API service or DB
const users = [
  { id: '123', email: '[email protected]' },
  { id: '456', email: '[email protected]' },
];

// Now we will export the BlueAuth handler and pass it
// a single configuration object which has a secret key,
// SMTP email information, and two functions;
// findUniqueIdentity to retrieve a user, and
// createIdentity to create a user
export const handler = blueauthHandler({
  secret: 'mySecretForSigning',
  authEndpoint: 'https://myapp.com/api/blueauth', // used for links in emails
  smtpURL: 'smtps://postmaster:[email protected]/', // for sending emails
  smtpFromAddress: '[email protected]',
  findUniqueIdentity: async (payload) => {
    // This is the function used to try to find a given user / identity.
    // The payload here is what you sent to the API, which you will see below.
    // return a single found user / identity, or falsey if none found

    console.log('> looking for a user that matches', payload);

    const user = users.find((user) => (user.email === payload.email || user.id === payload.id));
    // Another example where we are getting users from an API;
    // const user = await fetch('https://secure-api.example-b.com/findUser', { method: 'post', body: JSON.stringify(payload) });

    if (user) {
      console.log('> found an existing user!', user);
      return user;
    } else {
      console.log('> could not find a matching user');
      return null;
    }
  },
  createIdentity: async (payload) => {
    // This is called when a registration is started via the API.

    console.log('> Creating a user with the following info', payload);

    const newId = '789';
    const newUser = { id: newId, ...payload };
    users.push(newUser);
    // const newUser = await fetch('https://secure-api.example-b.com/createUser', { method: 'post', body: JSON.stringify(payload) });
    return newUser;
  },
});

// pages/sign-in.jsx
import React, { useState } from 'react';
import blueauth from 'blueauth-client';

export default function Page() {
  const [email, setEmail] = useState('[email protected]');

  const handleRegister = async () => {
    // This will hit the createIdentity, with the results returned here.
    // By default this does not sign them in.
    // Can enable auto sign in the config options, or implement own logic.
    const { result } = await blueauth().register({ identity: { email } });
    console.log('> new user', result); // whatever is returned from createIdentity
  };

  const handleSignIn = async () => {
    // This will hit the findUniqueIdentity to find a user
    // If it returns a user, an email will be sent with a sign in link
    //   (to the user's email attribute)
    // after clicking the sign in link in the email, they will be sent to redirectURL (default of '/')
    const { result } = await blueauth().startEmailSignIn({
       identity: { email },
       redirectURL: '/dashboard'
    });
    console.log('> is sign in started:', result); // true or false
  };

  const handleRegisterOrSignIn = async () => {
    // This is a combination of register + start sign in.
    //
    // The back end library will first try to find a user with findUniqueIdentity
    // If it finds a user, it will send a sign in email
    // If it does not find a user, it will create one using createIdentity, then send a sign in email
    //   (or if signInAfterRegistration is set to true, a new user will be auto signed in)
    const { result } = await blueauth().registerOrStartEmailSignIn({
      identity: { email },
      redirectURL: '/dashboard'
    });
    // result is SIGN_IN_STARTED (or SIGN_IN_COMPLETED for new user auto sign in)
    console.log('> is new user or is sign in started?', result);
  };

  const handleWhoami = async () => {
    // This does an API call that uses the id stored in the secure cookie
    // and passes it to findUniqueIdentity to find the corresponding user.
    // in other words, in findUniqueIdentity payload is { id: 'someIdHere' }
    const { whoami } = await blueauth().getSelf();
    console.log('> you are', whoami); // whatever is returned from findUniqueIdentity
  };

  const handleSignOut = async () => {
    // This does an API call that deletes the cookie that stores the session information
    const { result } = await blueauth().signOut();
    console.log('> is signed out', result); // true
  };

  return (
    <div>
      <h1>sign in</h1>
      <input
        placeholder="[email protected]"
        type="email"
        onChange={(event) => setEmail(event.target.value)}
      />
      <button onClick={handleRegister}>Register</button>
      <button onClick={handleSignIn}>sign in</button>
      <button onClick={handleRegisterOrSignIn}>Start Register or Sign In</button>
      <button onClick={handleWhoami}>Who Am I?</button>
      <button onClick={handleSignOut}>Sign Out</button>
    </div>
  );
}

// pages/api/secureEndpoint.js
import { getIdentity } from 'blueauth/nextjs';

const users = [
  // just another example stub for users
];

// can use the same config object from before,
// but only the secret and findUniqueIdentity are needed
const config = {
  secret: 'mySecretForSigning',
  findUniqueIdentity: (identityPayload) => {
    return users.find((user) => (user.email === payload.email || user.id === payload.id));
  },
};

export default async function handler(req, res) {
  // getIdentity grabs the secure cookie from the request, validates it,
  // and passes the cookie's payload to findUniqueIdentity to return a user
  const user = await getIdentity(config)({ req });

  if (!user) return res.status(400).json({ error: 'must be signed in!' });
  
  console.log('> user is', user);
  return res.status(200).json({
    userStuff: 'really secret',
    favoriteColor: user.favoriteColor
  });
}

// pages/dashboard.jsx
import { getIdentity } from 'blueauth/nextjs';

export default function Page({ user }) {
  const handleUserClick = async () => {
    // credentials must be include to send the auth cookies along with the request
    const result = await fetch('/api/secureEndpoint', { credentials: 'include' });
    // (Don't forget to use getIdentity on the server side to retrive this request's user!)
    const jsonResults = await result.json();
    console.log('> your results are', { jsonResults });
  };

  return (
    <div>
      <p>Hi! Your email is {user.email}!</p>
      <button onClick={handleUserClick}>Click to do a request</button>
    </div>
  );
}

export const getServerSideProps = async (context) => {
  const config = { /* your config */ };
  const user = await getIdentity(config)(context);

  if (!user) return { redirect: { destination: '/sign-in' } };
  return { props: { user } };
};

  const createSignInEmailStrings = ({ url }) => {
    return {
      text: `Please visit ${url} in your browser to sign in`,
      html: `Please click <a href="${url}">HERE</a> to sign in`,
    };
  };

import express from 'express';
import { getIdentity, handler } from 'blueauth/express';

const app = express();

const config = { /* your config */ };

app.use('/api/blueauth', handler(config));

app.get('/api/secureEndpoint', async (req, res) => {
  const user = await getIdentity(config)({ req });

  if (!user) return res.status(400).json({ error: 'must be signed in!' });

  return res.status(200).json({
    userStuff: 'really secret',
    favoriteColor: user.favoriteColor,
  });
});

app.listen(8080);

import { handler } from 'blueauth/lambda';
const config = { /* your config */ };
export default async (event) => handler(config)(event);