const serverToServerAuthDetails = {
    clientId: "<clientId>",
    clientSecret: "<clientSecret>",
    scopes: "<scopes>",
};

// create auth provider
// ServerToServerTokenProvider implements the TokenProvider interface that returns the access token.
const authProvider = new ServerToServerTokenProvider(serverToServerAuthDetails);
const config = {
    tokenProvider: authProvider,
    clientId: "<clientId>",
};

// create the product client
const firefly = new FireflyClient(config);

// Create client Credentials 
const clientCredentials = {
    clientId: "<clientId>",
    clientSecret: "<clientSecret>"
}

const firefly = await FireflyClient(clientCredentials);

const { PhotoshopClient } = require("@adobe/photoshop-apis");
const { FireflyClient } = require("@adobe/firefly-apis");
const { LightroomClient, StorageType } = require("@adobe/lightroom-apis");
const { ServerToServerTokenProvider } = require("@adobe/firefly-services-common-apis");

/**
 * Helper function that performs server-to-server authentication to fetch the access token.
 * @param {string} clientId
 * @param {string} clientSecret
 * @param {string} scopes
 * @returns {ServerToServerTokenProvider}
 */
function getAuthProvider(clientId, clientSecret, scopes) {
    const serverToServerAuthDetails = {
        clientId,
        clientSecret,
        scopes, // example: "openid,AdobeID,read_organizations,firefly_api,ff_apis"
    };
    const serverToServerAuthOptions = {
        autoRefresh: true,
    };
    return new ServerToServerTokenProvider(serverToServerAuthDetails, serverToServerAuthOptions);
}

// create auth config
const authProvider = getAuthProvider("<clientId>", "<clientSecret>", "<scopes>"); // Update the "<clientId>", "<clientSecret>", "<scopes>"
const config = {
    tokenProvider: authProvider,
    clientId: "<clientId>" // Update the "<clientId>"
};

// create the product clients
const firefly = new FireflyClient(config);
const photoshop = new PhotoshopClient(config);
const lightroom = new LightroomClient(config);

/**
 * Generate an image and remove background
 */
async function generateImageAndRemoveBackground() {
    const fireflyResponse = await firefly.generateImages({ prompt: "<Prompt>" }); // provide a `prompt` value
    const firstImageUrl = fireflyResponse.result.outputs[0].image.url;

    console.log("Successfully generated a Firefly Image");

    // Prepare for Photoshop operation
    const psInput = {
        href: firstImageUrl,
        storage: StorageType.EXTERNAL,
    };

    const psOutput = {
        href: "<psOutputHref>", // Update with generated Pre-signed PUT URL for output file. 
        storage: "<psOutputStorage>", // example: StorageType.DROPBOX or StorageType.EXTERNAL or StorageType.AZURE
    };

    const psRequestBody = {
        input: psInput,
        output: psOutput
    };

    const removeBg = await photoshop.removeBackground(psRequestBody); // Remove Background
    console.log("Successfully removed background");
}

/**
 * Generate an image and apply auto-tone
 */
async function generateAndAutoToneImage() {

    const fireflyResponse = await firefly.generateImages({ prompt: "<prompt>" }); // Update the "<prompt>"
    const firstImageUrl = fireflyResponse.result.outputs[0].image.url;

    console.log("Successfully generated the Firefly Image");

    // Prepare for Lightroom operation
    const lrInput = {
        href: firstImageUrl,
        storage: StorageType.EXTERNAL,
    };

    const lrOutput = {
        href: "<lrOutputHref>", // Update with generated pre-signed PUT URL for output file. 
        storage: "<lrOutputStorage>", // example -> "dropbox" or "external" or "azure"
        type: "<imageType>" // example -> "image/jpeg" or "image/png"
    };

    const lrRequestBody = {
        inputs: lrInput,
        outputs: [lrOutput]
    };

    const applyAutoTone = await lightroom.applyAutoTone(lrRequestBody); // Apply Auto Tone
    console.log("Successfully applied auto tone to the Image");
}

generateImageAndRemoveBackground();
generateAndAutoToneImage();