const scraper = await getScraper({ authMethod: 'password' });

scraper.getCookies().then((cookies) => {
  console.log(cookies);
  // Remove 'Cookies' and save the cookies as a JSON array
});

const scraper = new Scraper();
await scraper.login('username', 'password');

// If using v2 functionality (currently required to support polls)
await scraper.login(
  'username',
  'password',
  'email',
  'appKey',
  'appSecret',
  'accessToken',
  'accessSecret',
);

const tweets = await scraper.getTweets('elonmusk', 10);
const tweetsAndReplies = scraper.getTweetsAndReplies('elonmusk');
const latestTweet = await scraper.getLatestTweet('elonmusk');
const tweet = await scraper.getTweet('1234567890123456789');
await scraper.sendTweet('Hello world!');

// Create a poll
await scraper.sendTweetV2(
  `What's got you most hyped? Let us know! 🤖💸`,
  undefined,
  {
    poll: {
      options: [
        { label: 'AI Innovations 🤖' },
        { label: 'Crypto Craze 💸' },
        { label: 'Both! 🌌' },
        { label: 'Neither for Me 😅' },
      ],
      durationMinutes: 120, // Duration of the poll in minutes
    },
  },
);

// Fetch a single tweet with poll details
const tweet = await scraper.getTweetV2('1856441982811529619', {
  expansions: ['attachments.poll_ids'],
  pollFields: ['options', 'end_datetime'],
});
console.log('tweet', tweet);

// Fetch multiple tweets with poll and media details
const tweets = await scraper.getTweetsV2(
  ['1856441982811529619', '1856429655215260130'],
  {
    expansions: ['attachments.poll_ids', 'attachments.media_keys'],
    pollFields: ['options', 'end_datetime'],
    mediaFields: ['url', 'preview_image_url'],
  },
);
console.log('tweets', tweets);

// Log in
await scraper.login('username', 'password');

// Log out
await scraper.logout();

// Check if logged in
const isLoggedIn = await scraper.isLoggedIn();

// Get current session cookies
const cookies = await scraper.getCookies();

// Set current session cookies
await scraper.setCookies(cookies);

// Clear current cookies
await scraper.clearCookies();

// Get a user's profile
const profile = await scraper.getProfile('TwitterDev');

// Get a user ID from their screen name
const userId = await scraper.getUserIdByScreenName('TwitterDev');

// Get logged-in user's profile
const me = await scraper.me();

import { SearchMode } from 'agent-twitter-client';

// Search for recent tweets
const tweets = scraper.searchTweets('#nodejs', 20, SearchMode.Latest);

// Search for profiles
const profiles = scraper.searchProfiles('John', 10);

// Fetch a page of tweet results
const results = await scraper.fetchSearchTweets('#nodejs', 20, SearchMode.Top);

// Fetch a page of profile results
const profileResults = await scraper.fetchSearchProfiles('John', 10);

// Get a user's followers
const followers = scraper.getFollowers('12345', 100);

// Get who a user is following
const following = scraper.getFollowing('12345', 100);

// Fetch a page of a user's followers
const followerResults = await scraper.fetchProfileFollowers('12345', 100);

// Fetch a page of who a user is following
const followingResults = await scraper.fetchProfileFollowing('12345', 100);

// Follow a user
const followUserResults = await scraper.followUser('elonmusk');

// Get current trends
const trends = await scraper.getTrends();

// Fetch tweets from a list
const listTweets = await scraper.fetchListTweets('1234567890', 50);

// Get a user's tweets
const tweets = scraper.getTweets('TwitterDev');

// Fetch the home timeline
const homeTimeline = await scraper.fetchHomeTimeline(10, [
  'seenTweetId1',
  'seenTweetId2',
]);

// Get a user's liked tweets
const likedTweets = scraper.getLikedTweets('TwitterDev');

// Get a user's tweets and replies
const tweetsAndReplies = scraper.getTweetsAndReplies('TwitterDev');

// Get tweets matching specific criteria
const timeline = scraper.getTweets('TwitterDev', 100);
const retweets = await scraper.getTweetsWhere(
  timeline,
  (tweet) => tweet.isRetweet,
);

// Get a user's latest tweet
const latestTweet = await scraper.getLatestTweet('TwitterDev');

// Get a specific tweet by ID
const tweet = await scraper.getTweet('1234567890123456789');

// Send a tweet
const sendTweetResults = await scraper.sendTweet('Hello world!');

// Send a quote tweet - Media files are optional
const sendQuoteTweetResults = await scraper.sendQuoteTweet(
  'Hello world!',
  '1234567890123456789',
  ['mediaFile1', 'mediaFile2'],
);

// Retweet a tweet
const retweetResults = await scraper.retweet('1234567890123456789');

// Like a tweet
const likeTweetResults = await scraper.likeTweet('1234567890123456789');

// Example: Sending a tweet with media attachments
const mediaData = [
  {
    data: fs.readFileSync('path/to/image.jpg'),
    mediaType: 'image/jpeg',
  },
  {
    data: fs.readFileSync('path/to/video.mp4'),
    mediaType: 'video/mp4',
  },
];

await scraper.sendTweet('Hello world!', undefined, mediaData);

// Image formats and their MIME types
const imageTypes = {
  '.jpg': 'image/jpeg',
  '.jpeg': 'image/jpeg',
  '.png': 'image/png',
  '.gif': 'image/gif',
};

// Video format
const videoTypes = {
  '.mp4': 'video/mp4',
};

const scraper = new Scraper();
await scraper.login('username', 'password');

// Start a new conversation
const response = await scraper.grokChat({
  messages: [{ role: 'user', content: 'What are your thoughts on AI?' }],
});

console.log(response.message); // Grok's response
console.log(response.messages); // Full conversation history

const response = await scraper.grokChat({
  messages: [{ role: 'user', content: 'Hello!' }],
});

if (response.rateLimit?.isRateLimited) {
  console.log(response.rateLimit.message);
  console.log(response.rateLimit.upsellInfo); // Premium upgrade information
}

interface GrokChatOptions {
  messages: GrokMessage[];
  conversationId?: string;
  returnSearchResults?: boolean;
  returnCitations?: boolean;
}

interface GrokChatResponse {
  conversationId: string;
  message: string;
  messages: GrokMessage[];
  webResults?: any[];
  metadata?: any;
  rateLimit?: GrokRateLimit;
}

const response = await scraper.grokChat({
  messages: [{ role: 'user', content: 'Research quantum computing' }],
  returnSearchResults: true, // Include web search results
  returnCitations: true, // Include citations for information
});

// Access web results if available
if (response.webResults) {
  console.log('Sources:', response.webResults);
}

// Full conversation with history
console.log('Conversation:', response.messages);

import { Scraper } from 'agent-twitter-client';
import fs from 'fs'; // Assuming you might save/load cookies

async function runRadarExample() {
  const scraper = new Scraper();

  // --- Authentication ---
  // Ensure you are logged in. You might load cookies or log in via credentials.
  // Replace with your actual login logic (credentials or loading saved cookies)
  try {
    // Example: Load cookies if they exist
    const cookies = JSON.parse(fs.readFileSync('cookies.json', 'utf-8'));
    await scraper.setCookies(cookies);
    if (!(await scraper.isLoggedIn())) {
      throw new Error('Failed to log in with cookies.');
    }
    console.log('Logged in successfully using saved cookies.');
  } catch (error) {
    console.log(
      'No saved cookies found or login failed, logging in with credentials...',
    );
    // Replace with your actual credentials or environment variables
    await scraper.login(
      process.env.TWITTER_USERNAME!,
      process.env.TWITTER_PASSWORD!,
      process.env.TWITTER_EMAIL, // Optional email
      // Add other necessary login params like 2FA if needed
    );
    console.log('Logged in successfully using credentials.');
    // Optional: Save cookies for next time
    // const currentCookies = await scraper.getCookies();
    // fs.writeFileSync('cookies.json', JSON.stringify(currentCookies));
  }

  // --- Radar Workflow ---
  const query = '"artificial intelligence" OR #AI -is:retweet'; // Example advanced query
  let insightRestId: string | null = null;

  try {
    // 1. Create an Insight Rule
    console.log(`Creating insight rule for query: ${query}`);
    const createResult = await scraper.createInsightInputQuery(query);
    insightRestId = createResult.rest_id; // Use rest_id!
    console.log(`Insight rule created. Rest ID: ${insightRestId}`);

    // 2. (Recommended) Initialize the Rule
    console.log(`Initializing rule with ID: ${insightRestId}`);
    // This call might not return immediately useful data, but is often necessary
    await scraper.insightProviderGetQuery(insightRestId);
    console.log('Rule initialization called.');
    // Add a small delay if needed, as initialization might take time
    await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait 2 seconds

    // 3. Fetch Post Counts
    const sevenDaysAgo = Math.floor(Date.now() / 1000) - 7 * 24 * 60 * 60;
    const now = Math.floor(Date.now() / 1000);
    console.log(
      `Fetching post counts for rule ${insightRestId} from ${new Date(
        sevenDaysAgo * 1000,
      ).toISOString()} to ${new Date(now * 1000).toISOString()}`,
    );
    const postCounts = await scraper.usePostCountQuery(
      insightRestId,
      sevenDaysAgo,
      now,
    );
    // Process the complex response structure (refer to UsePostCountQueryResponse in radar.ts)
    const countsData =
      postCounts?.data?.viewer_v2?.user_results?.result?.insight_rule_by_id
        ?.matched_post_counts;
    if (countsData) {
      console.log(`Total posts found: ${countsData.total}`);
      console.log('Daily counts:', countsData.counts);
    } else {
      console.log('Could not extract post count data from response.');
      // console.log('Raw Post Count Response:', JSON.stringify(postCounts, null, 2)); // For debugging
    }

    // 4. Fetch Top Posts (using the query string, not rest_id)
    console.log(`Fetching top posts for query: ${query}`);
    const topPosts = await scraper.postListQuery(query);
    // Process the complex response structure (refer to PostListQueryResponse in radar.ts)
    const timelineInstructions =
      topPosts?.data?.search_by_raw_query?.search_timeline?.timeline
        ?.instructions;
    const tweetEntries = timelineInstructions
      ?.find((inst) => inst.__typename === 'TimelineAddEntries')
      ?.entries?.filter(
        (entry) => entry?.content?.__typename === 'TimelineTimelineItem',
      );

    if (tweetEntries && tweetEntries.length > 0) {
      console.log(`Found ${tweetEntries.length} top tweets:`);
      tweetEntries.forEach((entry: any, index: number) => {
        // Use 'any' or define a stricter type based on the interface
        const tweetResult = entry?.content?.content?.tweet_results?.result;
        if (tweetResult?.__typename === 'Tweet') {
          console.log(
            `  ${index + 1}. ID: ${
              tweetResult.rest_id
            }, Text: ${tweetResult.legacy.full_text.substring(0, 50)}...`,
          );
        }
      });
    } else {
      console.log('No top tweets found or could not extract from response.');
      // console.log('Raw Top Posts Response:', JSON.stringify(topPosts, null, 2)); // For debugging
    }

    // 5. List All Insight Rules
    console.log('Listing all current insight rules...');
    const allRules = await scraper.insightsListContextQuery();
    const rulesList =
      allRules?.data?.viewer_v2?.user_results?.result?.insight_rules?.items;
    if (rulesList) {
      console.log(`Found ${rulesList.length} rules:`);
      rulesList.forEach((rule: any) => {
        // Use 'any' or define a stricter type
        console.log(
          `  - ID: ${rule.rest_id}, Query: ${rule.core.advanced_query}`,
        );
      });
    } else {
      console.log('Could not list insight rules.');
    }
  } catch (error) {
    console.error('An error occurred during the Radar workflow:', error);
  } finally {
    // 6. Delete the Insight Rule (Optional Cleanup)
    if (insightRestId) {
      try {
        console.log(`Attempting to delete insight rule: ${insightRestId}`);
        await scraper.deleteInsightButtonMutation(insightRestId);
        console.log(`Successfully deleted insight rule: ${insightRestId}`);
      } catch (deleteError) {
        console.error(
          `Failed to delete insight rule ${insightRestId}:`,
          deleteError,
        );
      }
    }

    // Log out if necessary
    // await scraper.logout();
    // console.log('Logged out.');
  }
}

runRadarExample();