From Gmail to your Kobo for AO3 subscriptions

const CONFIG = {
  // change to your incoming AO3 emails gmail label
  gmailLabel: '60-69 Media/62.02 ao3',
  // change to your done AO3 emails gmail label
  successLabel: '60-69 Media/62.02 ao3/kobo',
  senderEmail: 'do-not-reply@archiveofourown.org',
  dropboxFolderPath: '/Apps/Rakuten Kobo',
  //dropboxFolderPath: '/Ao3Kobo',
  maxPerRun: 7,
  minDelayMsBetweenDownloads: 1200,

  // Recommended: treat gmailLabel as a true “queue”
  // If true: once processed, message/thread is removed from the queue label.
  removeQueueLabelOnSuccess: false
};

const DROPBOX_SCOPES = [
  'files.content.write',
  'files.metadata.read'
];

const DEBUG = true; // ← turn logs on/off here

// function setupDropboxAuth() {
//   return dropboxGetRedirectUri_();
// }

// function authorizeDropbox() {
//  return dropboxAuthorize_();
// }



function runPoller() {
  debugLog_('▶ runPoller start');

  Logger.log('typeof OAuth2 = ' + typeof OAuth2);

  const queueLabel = GmailApp.getUserLabelByName(CONFIG.gmailLabel);
  if (!queueLabel) {
	Logger.log(`✖ Gmail label not found: ${CONFIG.gmailLabel}`);
	throw new Error(`Missing Gmail label: ${CONFIG.gmailLabel}`);
  }
  Logger.log(`✔ Found label: ${CONFIG.gmailLabel}`);

  let successLabel = GmailApp.getUserLabelByName(CONFIG.successLabel);
  if (!successLabel) {
  successLabel = GmailApp.createLabel(CONFIG.successLabel);
  Logger.log(`✔ Created label: ${CONFIG.successLabel}`);
  } else {
  Logger.log(`✔ Found success label: ${CONFIG.successLabel}`);
  }




  const threads = queueLabel.getThreads(0, 50);
  Logger.log(`• Found ${threads.length} threads under label`);

  let processed = 0;

  for (const thread of threads) {
	Logger.log(`→ Thread ${thread.getId()}`);
	const messages = thread.getMessages();
	Logger.log(`  → ${messages.length} message(s) in thread`);

	for (const msg of messages) {
	  if (processed >= CONFIG.maxPerRun) {
		Logger.log('⏹ Reached maxPerRun, stopping');
		return;
	  }

	  const msgId = msg.getId();
	  Logger.log(`→ Checking message ${msgId}`);

	  // Only process unread messages: read == done
	  if (!msg.isUnread()) {
		Logger.log('  ⏭ Message already read (treated as processed), skipping');
		continue;
	  }

	  // Only process AO3 sender
	  const from = msg.getFrom() || '';
	  if (!from.includes(CONFIG.senderEmail)) {
		Logger.log(`  ⏭ Sender does not match AO3 (${from}), skipping`);
		continue;
	  }
	  Logger.log('  ✓ Sender matches AO3');

	  try {
		const text = msg.getPlainBody() || '';

		// ✅ Chapters gate BEFORE downloading
		const ch = isAo3EmailComplete_(text);

		if (ch.status !== 'complete') {
		  Logger.log(`  ⏭ Skipping: chapters not complete (${ch.status}${ch.current ? ` ${ch.current}/${ch.total ?? '?'}` : ''})`);

		  // SKIP state (what you asked for):
		  // - star it (visible)
		  // - mark read (so it doesn't retry forever)
		  msg.star();
		  msg.markRead();

		  // Optional: also remove from the queue label so it stops clogging the label view
		  // (This does NOT delete the email.)
		  // queueLabel.removeFromThread(thread);
		  continue;
		}

		const workId = extractAo3WorkId_(text);
		if (!workId) {
		  throw new Error('AO3 work ID not found in email body');
		}
		Logger.log(`  ✓ Extracted workId: ${workId}`);

		Logger.log('  → Fetching EPUB from AO3');
		const { blob, filename } = downloadEpubAndName_(workId);
		Logger.log(`  ✓ EPUB downloaded: ${filename} (${blob.getBytes().length} bytes)`);

		const dropboxPath = `${CONFIG.dropboxFolderPath}/${sanitizeDropboxFilename_(filename)}`;
		Logger.log(`  → Uploading to Dropbox: ${dropboxPath}`);
		uploadToDropbox_(dropboxPath, blob);
		Logger.log('  ✓ Dropbox upload successful');

		// SUCCESS state:
		// - mark read (so we never do it again)
		// - unstar (clear any prior error)
		msg.markRead();
		msg.unstar();

		// Move thread from queue label → kobo label
		try {
		  queueLabel.removeFromThread(thread);
		  Logger.log(`  ✓ Removed queue label: ${CONFIG.gmailLabel}`);
		} catch (e) {
		  Logger.log(`  ⚠ Could not remove queue label: ${e}`);
		}

		try {
		  successLabel.addToThread(thread);
		  Logger.log(`  ✓ Added success label: ${CONFIG.successLabel}`);
		} catch (e) {
		  Logger.log(`  ⚠ Could not add success label: ${e}`);
		}


		processed += 1;
		Logger.log(`  ✓ Message ${msgId} processed successfully`);

		Utilities.sleep(CONFIG.minDelayMsBetweenDownloads);

	  } catch (err) {
		Logger.log(`✖ ERROR processing message ${msgId}: ${err && err.message ? err.message : err}`);

		// ERROR state:
		// - star it (visible)
		// - leave unread so it retries next run
		try { msg.star(); } catch (e) {}
		Logger.log('  → Message starred and left unread for retry');
	  }
	}
  }

  Logger.log('▶ runPoller finished');
}

function debugLog_(msg) {
  if (DEBUG) Logger.log(msg);
}

/** --- AO3 download --- */

function downloadEpubAndName_(workId) {
  const cookieVal = PropertiesService.getScriptProperties().getProperty('AO3_SESSION_COOKIE');
  if (!cookieVal) throw new Error('AO3_SESSION_COOKIE missing');

  const url = `https://archiveofourown.org/downloads/${workId}/a.epub`;
  Logger.log(`    → AO3 URL: ${url}`);

  // Follow redirects normally (AO3 often redirects to download.archiveofourown.org)

const resp = UrlFetchApp.fetch(url, {
  followRedirects: true,
  muteHttpExceptions: true,
  headers: {
	'User-Agent':
	  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' +
	  'AppleWebKit/537.36 (KHTML, like Gecko) ' +
	  'Chrome/120.0.0.0 Safari/537.36',
	...(cookieVal ? { 'Cookie': `_otwarchive_session=${cookieVal};` } : {})
  }
});

  const code = resp.getResponseCode();
  Logger.log(`    ← AO3 final response code: ${code}`);

  // If auth fails, the "final" response often becomes an HTML page (not an epub)
  const ct = (resp.getHeaders()['Content-Type'] || resp.getHeaders()['content-type'] || '').toLowerCase();
  Logger.log(`    ← AO3 content-type: ${ct}`);

  if (code === 401 || code === 403) {
	throw new Error(`AO3 denied access (${code})`);
  }
  if (code < 200 || code >= 400) {
	const snippet = safeSnippet_(resp.getContentText(), 300);
	throw new Error(`AO3 download failed (${code}). Snippet: ${snippet}`);
  }

  // Extra hardening: ensure we actually got an epub-ish response
  // (Some failures return HTML with 200)

  if (ct.includes('text/html')) {
	const html = resp.getContentText() || '';

	// Log a bit from later in the page too (reason text is often in the body)
	Logger.log(`    ← AO3 HTML diagnosis: ${diagnoseAo3Html_(html)}`);
	Logger.log(`    ← AO3 HTML head snippet: ${safeSnippet_(html, 300)}`);

	// Try to find a more meaningful snippet from the body
	const bodyish = html.replace(/[\s\S]*?<body[^>]*>/i, '').slice(0, 1200);
	Logger.log(`    ← AO3 HTML body snippet: ${safeSnippet_(bodyish, 400)}`);

	throw new Error('AO3 returned HTML instead of EPUB (see diagnosis above).');
  }


  const blob = resp.getBlob();

  // Filename from Content-Disposition if present
  const cd = resp.getHeaders()['Content-Disposition'] || resp.getHeaders()['content-disposition'] || '';
  const filename = extractFilenameFromContentDisposition_(cd) || `ao3_${workId}.epub`;

  return { blob, filename };
}


/** --- Dropbox upload --- */

function uploadToDropbox_(path, blob) {

  // Tripwire to force library resolution
  const __oauth2_loaded = typeof OAuth2;

  const service = getDropboxService_();
  if (!service.hasAccess()) {
	throw new Error('Dropbox not authorized. Run dropboxAuthorize_() and complete the auth flow.');
  }

  const token = service.getAccessToken();

  const apiArg = {
	path,
	mode: 'add',
	autorename: true,
	mute: false
  };
  Logger.log(`    → Dropbox API arg: ${JSON.stringify(apiArg)}`);

  const resp = UrlFetchApp.fetch('https://content.dropboxapi.com/2/files/upload', {
	method: 'post',
	contentType: 'application/octet-stream',
	payload: blob.getBytes(),
	headers: {
	  Authorization: `Bearer ${token}`,
	  'Dropbox-API-Arg': JSON.stringify(apiArg)
	},
	muteHttpExceptions: true
  });

  const code = resp.getResponseCode();
  const body = resp.getContentText() || '';
  Logger.log(`    ← Dropbox response code: ${code}`);
  Logger.log(`    ← Dropbox response body: ${safeSnippet_(body, 2000)}`);

  if (code < 200 || code >= 400) {
	throw new Error(`Dropbox upload failed (${code}). Body: ${safeSnippet_(body, 800)}`);
  }
}

/** --- Helpers (unchanged) --- */

function extractAo3WorkId_(text) {
  const m = (text || '').match(/https?:\/\/(?:www\.)?archiveofourown\.org\/works\/(\d+)/i);
  return m ? m[1] : null;
}

function sanitizeDropboxFilename_(name) {
  return (name || 'ao3.epub')
	.replace(/[\/\\]/g, '_')
	.replace(/[\u0000-\u001F\u007F]/g, '')
	.trim()
	.slice(0, 180);
}

function extractFilenameFromContentDisposition_(cd) {
  if (!cd) return null;
  let m = cd.match(/filename\*\s*=\s*UTF-8''([^;]+)/i);
  if (m) return decodeURIComponent(m[1]);
  m = cd.match(/filename\s*=\s*"?([^";]+)"?/i);
  return m ? m[1] : null;
}

function safeSnippet_(s, maxLen) {
  if (!s) return '';
  const clean = String(s).replace(/\s+/g, ' ').trim();
  return clean.length > maxLen ? clean.slice(0, maxLen) + '…' : clean;
}

function diagnoseAo3Html_(html) {
  const lower = (html || '').toLowerCase();

  // Common AO3 cases
  if (lower.includes('login') && (lower.includes('password') || lower.includes('log in'))) {
	return 'Looks like AO3 login page (session not authenticated).';
  }
  if (lower.includes('this work is only available to registered users')) {
	return 'Work restricted to registered users (should work when logged in).';
  }
  if (lower.includes('you do not have permission') || lower.includes('you are not allowed')) {
	return 'Permission/collection restriction (may be inaccessible even when logged in).';
  }
  if (lower.includes('adult content') && lower.includes('proceed')) {
	return 'Adult-content confirmation interstitial (needs preference/consent).';
  }
  if (lower.includes('retry later') || lower.includes('error') && lower.includes('back')) {
	return 'AO3 error page / temporary issue.';
  }
  return 'Unknown HTML page type.';
}

function getDropboxService_() {
  const props = PropertiesService.getScriptProperties();
  const clientId = props.getProperty('DROPBOX_CLIENT_ID');
  const clientSecret = props.getProperty('DROPBOX_CLIENT_SECRET');
  if (!clientId || !clientSecret) {
	throw new Error('Missing DROPBOX_CLIENT_ID or DROPBOX_CLIENT_SECRET in Script Properties.');
  }

  return OAuth2.createService('dropbox')
	.setAuthorizationBaseUrl('https://www.dropbox.com/oauth2/authorize')
	.setTokenUrl('https://api.dropboxapi.com/oauth2/token')
	.setClientId(clientId)
	.setClientSecret(clientSecret)
	.setCallbackFunction('dropboxAuthCallback_')

	// Store tokens here:
	.setPropertyStore(PropertiesService.getUserProperties())

	// Get refresh token
	.setParam('token_access_type', 'offline')

	// Ask for scopes
	.setScope(DROPBOX_SCOPES.join(' '))
}

function dropboxGetRedirectUri_() {
  const service = getDropboxService_();
  Logger.log(service.getRedirectUri());
  return service.getRedirectUri();
}

function dropboxAuthorize_() {
  const service = getDropboxService_();
  const url = service.getAuthorizationUrl();
  Logger.log(url);
  return url;
}

function dropboxAuthCallback_(request) {
  const service = getDropboxService_();
  const ok = service.handleCallback(request);
  return HtmlService.createHtmlOutput(ok ? 'Dropbox auth OK. You can close this.' : 'Dropbox auth denied.');
}

function dropboxResetAuth_() {
  getDropboxService_().reset();
}

function isAo3EmailComplete_(text) {
  const complete = /Chapters:\s*(\d+)\s*\/\s*\1\b/i.test(text || '');
  return complete ? { status: 'complete' } : { status: 'not-complete' };
}