// Scrape competitor followers on Instagram
const scraperConfig = {
  targetAccount: '@competitor_username',
  platform: 'instagram',
  filters: {
    minFollowers: 100,
    maxFollowers: 10000,
    activeWithinDays: 30,
    location: 'United States',
    verifiedOnly: false
  },
  maxResults: 5000
};

// Execute scrape
async function scrapeFollowers(config) {
  const results = await api.scrape({
    type: 'followers',
    target: config.targetAccount,
    platform: config.platform,
    filters: config.filters,
    limit: config.maxResults
  });
  
  return results.users; // Array of user objects
}

// Find users by hashtag on TikTok
const hashtagConfig = {
  hashtags: ['#skincare', '#beautyproducts', '#antiaging'],
  platform: 'tiktok',
  filters: {
    engagement: 'high', // high/medium/low
    accountAge: 90, // days
    followerRange: [500, 50000]
  },
  limit: 3000
};

async function getHashtagUsers(config) {
  const users = await api.extractByHashtag({
    tags: config.hashtags,
    platform: config.platform,
    filters: config.filters,
    maxUsers: config.limit
  });
  
  // AI filtering
  const filtered = await api.aiFilter(users, {
    detectGender: true,
    estimateAge: true,
    removeBusinessAccounts: false,
    removeBots: true
  });
  
  return filtered;
}

// Auto-engage with scraped users
const engagementConfig = {
  users: [], // Array from scraping
  actions: {
    follow: true,
    like: { enabled: true, postsCount: 3 },
    comment: { 
      enabled: true, 
      templates: [
        "Love this! 😍",
        "Amazing content! 🔥",
        "Great post! 💯"
      ],
      randomize: true
    }
  },
  timing: {
    delayBetweenUsers: [5000, 15000], // Random delay range (ms)
    dailyLimit: 100,
    stopOnError: false
  }
};

async function autoEngage(config) {
  for (const user of config.users) {
    try {
      if (config.actions.follow) {
        await api.follow(user.username);
        await delay(random(config.timing.delayBetweenUsers));
      }
      
      if (config.actions.like.enabled) {
        const posts = await api.getUserPosts(user.username, config.actions.like.postsCount);
        for (const post of posts) {
          await api.like(post.id);
          await delay(random(2000, 5000));
        }
      }
      
      if (config.actions.comment.enabled) {
        const comment = randomChoice(config.actions.comment.templates);
        await api.comment(posts[0].id, comment);
      }
      
      await delay(random(config.timing.delayBetweenUsers));
    } catch (error) {
      console.error(`Error engaging with ${user.username}:`, error);
      if (config.timing.stopOnError) break;
    }
  }
}

// Mass DM campaign
const dmConfig = {
  recipients: [], // User list from scraping
  message: {
    text: "Hi {name}! 👋 Noticed you're into {interest}. Check out our exclusive offer: {link}",
    variables: {
      link: process.env.LANDING_PAGE_URL,
      interest: 'skincare' // Dynamic per user
    },
    personalize: true
  },
  schedule: {
    messagesPerHour: 10,
    startTime: '09:00',
    endTime: '18:00',
    timezone: 'America/New_York'
  },
  tracking: {
    enabled: true,
    trackClicks: true,
    trackReplies: true
  }
};

async function sendBulkDMs(config) {
  const queue = [...config.recipients];
  
  while (queue.length > 0) {
    const batch = queue.splice(0, config.schedule.messagesPerHour);
    
    for (const user of batch) {
      const personalizedMsg = config.message.text
        .replace('{name}', user.name || user.username)
        .replace('{interest}', user.interests?.[0] || config.message.variables.interest)
        .replace('{link}', config.message.variables.link);
      
      await api.sendDM({
        to: user.username,
        message: personalizedMsg,
        platform: user.platform,
        trackingId: config.tracking.enabled ? generateTrackingId(user) : null
      });
      
      await delay(random(5000, 10000));
    }
    
    // Wait before next batch
    if (queue.length > 0) {
      await delay(3600000 / config.schedule.messagesPerHour);
    }
  }
}

// WhatsApp bulk sending
const whatsappConfig = {
  mode: 'group', // 'group' or 'individual'
  groups: [
    { id: 'group-id-1', name: 'Marketing Group' },
    { id: 'group-id-2', name: 'Sales Team' }
  ],
  message: {
    text: "🎉 New Product Launch! Check it out: {link}",
    media: {
      type: 'image',
      url: process.env.PRODUCT_IMAGE_URL
    }
  },
  schedule: {
    sendAt: '2026-06-01T10:00:00Z',
    timezone: 'UTC'
  }
};

async function sendWhatsAppBulk(config) {
  if (config.mode === 'group') {
    for (const group of config.groups) {
      await api.whatsapp.sendToGroup({
        groupId: group.id,
        text: config.message.text.replace('{link}', process.env.LANDING_PAGE_URL),
        media: config.message.media,
        scheduleTime: config.schedule.sendAt
      });
      
      await delay(random(30000, 60000)); // Delay between groups
    }
  }
}

# Platform Credentials
IG_USERNAME=your_instagram_username
IG_PASSWORD=your_instagram_password
TT_USERNAME=your_tiktok_username
TT_PASSWORD=your_tiktok_password
WA_PHONE=your_whatsapp_number

# Proxies (recommended to avoid bans)
IG_PROXY=http://proxy1.example.com:8080
TT_PROXY=http://proxy2.example.com:8080

# Campaign Settings
LANDING_PAGE_URL=https://yoursite.com/offer
PRODUCT_IMAGE_URL=https://yoursite.com/product.jpg
DAILY_FOLLOW_LIMIT=150
DAILY_MESSAGE_LIMIT=50

// Recommended rate limits to avoid platform detection
const safeLimits = {
  instagram: {
    followsPerHour: 20,
    likesPerHour: 60,
    commentsPerHour: 15,
    dmsPerHour: 10,
    dailyFollowLimit: 150,
    dailyUnfollowLimit: 150
  },
  tiktok: {
    followsPerHour: 30,
    likesPerHour: 100,
    commentsPerHour: 20,
    dmsPerHour: 15
  },
  whatsapp: {
    messagesPerHour: 30,
    groupsPerHour: 5
  }
};

// Implement delays
function getRandomDelay(min = 3000, max = 8000) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// Complete workflow: Scrape → Filter → Engage → Convert
async function competitorHijackingCampaign() {
  // Step 1: Scrape competitor followers
  const followers = await scrapeFollowers({
    targetAccount: '@main_competitor',
    platform: 'instagram',
    filters: { minFollowers: 500, maxFollowers: 20000 },
    maxResults: 2000
  });
  
  // Step 2: AI filter for quality
  const qualified = await api.aiFilter(followers, {
    removeBusinessAccounts: true,
    removeBots: true,
    estimateAge: true,
    ageRange: [18, 45]
  });
  
  // Step 3: Soft engagement
  await autoEngage({
    users: qualified.slice(0, 100), // Start with 100
    actions: {
      follow: true,
      like: { enabled: true, postsCount: 2 }
    },
    timing: { dailyLimit: 100 }
  });
  
  // Step 4: Wait 24-48h, then DM engaged users
  setTimeout(async () => {
    const engaged = await api.getFollowBacks(qualified);
    await sendBulkDMs({
      recipients: engaged,
      message: {
        text: "Hey {name}! Saw you follow @main_competitor. We have a better deal 😊 {link}"
      }
    });
  }, 86400000 * 2); // 48 hours
}

// Find hot leads via trending hashtags
async function hashtagFunnel() {
  const leads = await getHashtagUsers({
    hashtags: ['#needthis', '#wheretobuy', '#recommendations'],
    platform: 'tiktok',
    filters: { engagement: 'high' },
    limit: 1000
  });
  
  // Immediate soft touch
  await autoEngage({
    users: leads,
    actions: {
      follow: true,
      like: { enabled: true, postsCount: 1 },
      comment: { 
        enabled: true,
        templates: ["Check your DMs! 💌"]
      }
    }
  });
  
  // Same-day DM with solution
  await sendBulkDMs({
    recipients: leads,
    message: {
      text: "Hi! Saw your post about {interest}. We've got exactly what you need: {link}"
    },
    schedule: { messagesPerHour: 20 }
  });
}

// Coordinate campaigns across IG + TikTok + WhatsApp
async function multiPlatformBlitz() {
  const igUsers = await scrapeFollowers({
    targetAccount: '@competitor_ig',
    platform: 'instagram',
    maxResults: 1000
  });
  
  const ttUsers = await getHashtagUsers({
    hashtags: ['#productniche'],
    platform: 'tiktok',
    limit: 1000
  });
  
  // Parallel engagement
  await Promise.all([
    autoEngage({ users: igUsers, actions: { follow: true, like: { enabled: true, postsCount: 2 } } }),
    autoEngage({ users: ttUsers, actions: { follow: true, comment: { enabled: true } } })
  ]);
  
  // Collect phone numbers from bio scraping (if available)
  const phoneNumbers = await api.extractPhoneNumbers([...igUsers, ...ttUsers]);
  
  // WhatsApp retargeting
  if (phoneNumbers.length > 0) {
    await api.whatsapp.sendBulk({
      recipients: phoneNumbers,
      message: "Special offer for our social followers! {link}"
    });
  }
}

// Add randomization and longer delays
const conservativeConfig = {
  delayBetweenActions: [10000, 30000], // 10-30 seconds
  dailyFollowLimit: 50, // Reduce from 150
  dailyMessageLimit: 20, // Reduce from 50
  randomizeDelays: true,
  useProxy: true,
  rotateProxies: true,
  sessionDuration: [1800000, 3600000] // 30-60 min sessions
};

// Add session breaks
async function engageWithBreaks(users) {
  const sessionSize = 20;
  for (let i = 0; i < users.length; i += sessionSize) {
    const batch = users.slice(i, i + sessionSize);
    await autoEngage({ users: batch });
    
    // Break between sessions (15-30 min)
    if (i + sessionSize < users.length) {
      await delay(random(900000, 1800000));
    }
  }
}

// Better personalization
async function improvePersonalization(user) {
  const recentPosts = await api.getUserPosts(user.username, 5);
  const interests = await api.extractInterests(recentPosts);
  
  const templates = {
    skincare: "Hey {name}! Your skin looks amazing in your recent posts! Have you tried {product}?",
    fitness: "Hi {name}! Loved your workout content. Check out our fitness supplement: {link}",
    fashion: "Hey {name}! Your style is 🔥 You'd love our new collection: {link}"
  };
  
  const category = interests[0] || 'general';
  return templates[category] || templates.general;
}

// Send at optimal times
const optimalTimes = {
  instagram: ['10:00', '14:00', '19:00'], // Peak engagement hours
  tiktok: ['12:00', '17:00', '21:00']
};

// Deduplicate across campaigns
const seenUsers = new Set();

function deduplicateUsers(users) {
  return users.filter(user => {
    const key = `${user.platform}:${user.username}`;
    if (seenUsers.has(key)) return false;
    seenUsers.add(key);
    return true;
  });
}

// Persist to avoid re-contacting
const fs = require('fs');
function saveContactedUsers(users) {
  const existing = JSON.parse(fs.readFileSync('contacted.json', 'utf8') || '[]');
  const updated = [...existing, ...users.map(u => u.username)];
  fs.writeFileSync('contacted.json', JSON.stringify([...new Set(updated)]));
}

// Proxy rotation
const proxyPool = [
  process.env.PROXY_1,
  process.env.PROXY_2,
  process.env.PROXY_3
];

let currentProxyIndex = 0;

function getNextProxy() {
  const proxy = proxyPool[currentProxyIndex];
  currentProxyIndex = (currentProxyIndex + 1) % proxyPool.length;
  return proxy;
}

// Account rotation for high-volume
const accountPool = [
  { username: process.env.IG_USER_1, password: process.env.IG_PASS_1 },
  { username: process.env.IG_USER_2, password: process.env.IG_PASS_2 }
];

async function distributeLoad(users, action) {
  const perAccount = Math.ceil(users.length / accountPool.length);
  
  for (let i = 0; i < accountPool.length; i++) {
    const batch = users.slice(i * perAccount, (i + 1) * perAccount);
    await api.switchAccount(accountPool[i]);
    await action(batch);
  }
}

// Add opt-out footer to all DMs
const compliantMessage = `
${originalMessage}

---
Reply STOP to opt out of future messages.
`;

// Track opt-outs
async function checkOptOut(username) {
  const optOuts = JSON.parse(fs.readFileSync('optouts.json', 'utf8') || '[]');
  return optOuts.includes(username);
}