import { Maxim } from '@maximai/maxim-js';

// Basic initialization
const maxim = new Maxim({
  apiKey: 'your-api-key'
});

// Full configuration
const maxim = new Maxim({
  apiKey: 'your-api-key',
  baseUrl: 'https://app.getmaxim.ai',
  promptManagement: true,
  debug: true,
  cache: new CustomCacheImplementation()
});

// Using prompt management
const maxim = new Maxim({
  apiKey: 'your-api-key',
  promptManagement: true
});

// Get a prompt with deployment rules
const rule = new QueryBuilder()
  .deploymentVar('environment', 'production')
  .tag('version', 'v2.0')
  .build();

const prompt = await maxim.getPrompt('prompt-id', rule);
if (prompt) {
  const response = await prompt.run('Hello world');
  console.log(response.choices[0].message.content);
}

// Creating and running test runs
const testResult = await maxim
  .createTestRun('sample-test-run', 'workspace-id')
  .withDataStructure({
    input: 'INPUT',
    expectedOutput: 'EXPECTED_OUTPUT'
  })
  .withData('dataset-id')
  .withEvaluators('bias', 'toxicity')
  .yieldsOutput(async (data) => {
    const response = await callYourModel(data.input);
    return { data: response };
  })
  .run();

// Logging with Maxim
const logger = await maxim.logger({ id: 'my-app' });
const trace = session.trace({ id: 'trace-1', name: 'Query Processing', sessionId: 'session-1' });

// ... Log other operations

trace.end();

// finally, before app shutdown
await maxim.cleanup();

const maxim = new Maxim({
  apiKey: process.env.MAXIM_API_KEY,
  promptManagement: true,
  debug: process.env.NODE_ENV === 'development'
});

// With custom cache
import { RedisCacheImplementation } from './custom-cache';

const maxim = new Maxim({
  apiKey: 'your-api-key',
  cache: new RedisCacheImplementation({
    host: 'localhost',
    port: 6379
  })
});

// Always remember to cleanup before exit
process.on('SIGINT', async () => {
  await maxim.cleanup();
  process.exit(0);
});

await maxim.addDatasetEntries("datasetId", [
	{
		input: {
			type: VariableType.TEXT,
			payload: "cell value",
		},
	},
]);

// Basic cleanup on application shutdown
process.on('SIGINT', async () => {
  console.log('Shutting down gracefully...');
  await maxim.cleanup();
  process.exit(0);
});

// Cleanup in Express.js application
process.on('SIGTERM', async () => {
  console.log('SIGTERM received, shutting down...');
  await maxim.cleanup();
  server.close(() => {
    process.exit(0);
  });
});

// Cleanup in test suites
afterAll(async () => {
  await maxim.cleanup();
});

// You can keep chaining methods to
// the created test run to configure it
const testRun = maxim
    .createTestRun(
        "testRunName",
        "workspaceId"
    ); // .with___(...)

const folder = await maxim.getFolderById("folderId");

const folders = await maxim.getFolders(
 new QueryBuilder()
     .and()
     .deploymentVar("Environment", "Production")
     .build()
);

import { QueryBuilder } from '@maximai/maxim-js';

const rule = new QueryBuilder()
  .deploymentVar('environment', 'production')
  .tag('version', 'v2.0')
  .build();

const prompt = await maxim.getPrompt('user-greeting-prompt-id', rule);
if (prompt) {
  const response = await prompt.run('Hello!', {
    variables: { userName: 'John' },
    imageUrls: []
  });
  console.log(response.choices[0].message.content);
}

// Using folder-scoped queries
const rule = new QueryBuilder()
  .folder('customer-service-folder')
  .deploymentVar('language', 'en')
  .build();

const prompt = await maxim.getPrompt('support-template', rule);

import { QueryBuilder } from '@maximai/maxim-js';

const rule = new QueryBuilder()
  .deploymentVar('environment', 'production')
  .tag('version', 'v2.0')
  .build();

const promptChain = await maxim.getPromptChain('user-onboarding-chain-id', rule);
if (promptChain) {
  const response = await promptChain.run('New user registration', {
    variables: { userName: 'John', userType: 'premium' }
  });
  console.log(response.finalOutput);
}

// Using folder-scoped queries
const rule = new QueryBuilder()
  .folder('customer-onboarding-folder')
  .deploymentVar('language', 'en')
  .build();

const promptChain = await maxim.getPromptChain('welcome-sequence', rule);

import { QueryBuilder } from '@maximai/maxim-js';

// Get all production prompt chains in a specific folder
const rule = new QueryBuilder()
  .folder('customer-support')
  .deploymentVar('environment', 'production')
  .build();

const promptChains = await maxim.getPromptChains(rule);
if (promptChains) {
  for (const promptChain of promptChains) {
    console.log(`Prompt Chain: ${promptChain.promptChainId}, Version: ${promptChain.version}`);
  }
}

// Get all prompt chains with specific tags
const rule = new QueryBuilder()
  .tag('category', 'workflow')
  .tag('complexity', 'advanced')
  .and()
  .build();

const workflowChains = await maxim.getPromptChains(rule);

import { QueryBuilder } from '@maximai/maxim-js';

// Get all production prompts in a specific folder
const rule = new QueryBuilder()
  .folder('customer-support')
  .deploymentVar('environment', 'production')
  .build();

const prompts = await maxim.getPrompts(rule);
if (prompts) {
  for (const prompt of prompts) {
    console.log(`Prompt: ${prompt.promptId}, Version: ${prompt.version}`);
  }
}

// Get all prompts with specific tags
const rule = new QueryBuilder()
  .tag('category', 'greeting')
  .tag('language', 'english')
  .and()
  .build();

const greetingPrompts = await maxim.getPrompts(rule);

// Basic logger creation
const logger = await maxim.logger({
  id: 'my-repository-id',
});

if (logger) {
  // Create a session for user interactions
  const session = logger.session({
    id: 'user-session-123',
    name: 'Customer Support Chat'
  });

  // Create a trace for a specific operation
  const trace = session.trace({
    id: 'query-trace-456',
    name: 'Customer Query Processing'
  });

  // ... Log other operations

  trace.end();

  // finally, before app shutdown
  await maxim.cleanup();
}