Phase 3: Conversation & Approval Flow

const PairTelegramSchema = Type.Object({
  telegram_chat_id: Type.String(),
  customer_id: Type.Number(),
  pairing_code: Type.Optional(Type.String())
});

app.post<{ Body: typeof PairTelegramSchema.static }>('/telegram/pair', {
  schema: {
    body: PairTelegramSchema
  }
}, async (request, reply) => {
  const { telegram_chat_id, customer_id, pairing_code } = request.body;

  // Verify customer exists
  const { data: customer, error: customerError } = await supabase
    .from('customer_customer')
    .select('id, name')
    .eq('id', customer_id)
    .single();

  if (customerError || !customer) {
    return reply.code(404).send({ error: 'Customer not found' });
  }

  // If pairing code provided, verify it
  if (pairing_code) {
    // Check against stored pairing codes (implement custom logic)
    // For now, simple matching
  }

  // Create or update pairing
  const { data, error } = await supabase
    .from('telegram_client_mapping')
    .upsert({
      telegram_chat_id,
      customer_id,
      paired_at: new Date().toISOString(),
      is_active: true,
      last_interaction_at: new Date().toISOString()
    }, {
      onConflict: 'telegram_chat_id'
    })
    .select()
    .single();

  if (error) {
    return reply.code(500).send({ error: error.message });
  }

  return {
    success: true,
    customer_name: customer.name,
    paired_at: data.paired_at
  };
});

const BrandVoiceSchema = Type.Object({
  rule_type: Type.Union([
    Type.Literal('tone'),
    Type.Literal('terminology'),
    Type.Literal('audience'),
    Type.Literal('style')
  ]),
  rule_text: Type.String()
});

app.post<{
  Params: { id: string },
  Body: typeof BrandVoiceSchema.static
}>('/client/:id/brand-voice', {
  schema: {
    body: BrandVoiceSchema
  }
}, async (request, reply) => {
  const { id } = request.params;
  const { rule_type, rule_text } = request.body;

  const { data, error } = await supabase
    .from('client_brand_voice')
    .insert({
      customer_id: parseInt(id),
      rule_type,
      rule_text,
      source: 'manual'
    })
    .select()
    .single();

  if (error) {
    return reply.code(500).send({ error: error.message });
  }

  return data;
});

const ApprovalSchema = Type.Object({
  post_id: Type.Number(),
  action: Type.Union([
    Type.Literal('approve'),
    Type.Literal('reject'),
    Type.Literal('request_edit')
  ]),
  feedback: Type.Optional(Type.String())
});

app.post<{ Body: typeof ApprovalSchema.static }>('/post/approve', {
  schema: {
    body: ApprovalSchema
  }
}, async (request, reply) => {
  const { post_id, action, feedback } = request.body;

  let new_status: string;
  switch (action) {
    case 'approve':
      new_status = 'approved';
      break;
    case 'reject':
      new_status = 'rejected';
      break;
    case 'request_edit':
      new_status = 'revision_requested';
      break;
  }

  const { data, error } = await supabase
    .from('customer_posts')
    .update({
      status: new_status,
      updated_at: new Date().toISOString()
    })
    .eq('id', post_id)
    .select()
    .single();

  if (error) {
    return reply.code(500).send({ error: error.message });
  }

  // If feedback provided, store it for future reference
  if (feedback) {
    await supabase.from('post_feedback').insert({
      post_id,
      feedback_text: feedback,
      feedback_type: action
    });
  }

  return data;
});

app.post<{ Params: { id: string } }>('/client/:id/media', async (request, reply) => {
  const { id } = request.params;
  
  // Handle multipart upload or URL
  // Store in Supabase Storage, then create record
  
  const { data, error } = await supabase
    .from('client_content_asset')
    .insert({
      customer_id: parseInt(id),
      asset_type: 'image',
      url: 'stored_url_here',
      content: 'extracted_text_here',
      metadata: { source: 'telegram', uploaded_at: new Date().toISOString() }
    })
    .select()
    .single();

  if (error) {
    return reply.code(500).send({ error: error.message });
  }

  return data;
});

app.get('/posts/pending-reminders', async (request, reply) => {
  const { data, error } = await supabase
    .from('customer_posts')
    .select(`
      id,
      customer_id,
      title,
      created_at,
      customer:customer_customer(name),
      telegram:telegram_client_mapping(telegram_chat_id, last_interaction_at)
    `)
    .eq('status', 'pending_review')
    .lt('created_at', new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString());

  if (error) {
    return reply.code(500).send({ error: error.message });
  }

  // Group by customer
  const byCustomer = data.reduce((acc, post) => {
    const cid = post.customer_id;
    if (!acc[cid]) acc[cid] = [];
    acc[cid].push(post);
    return acc;
  }, {} as Record<number, any[]>);

  return Object.entries(byCustomer).map(([customer_id, posts]) => ({
    customer_id: parseInt(customer_id),
    telegram_chat_id: posts[0].telegram[0]?.telegram_chat_id,
    post_count: posts.length,
    oldest_post_age_hours: Math.floor(
      (Date.now() - new Date(posts[0].created_at).getTime()) / (1000 * 60 * 60)
    )
  }));
});

// In /publish endpoint, after successful publish:
const { data: mapping } = await supabase
  .from('telegram_client_mapping')
  .select('telegram_chat_id')
  .eq('customer_id', customer_id)
  .single();

if (mapping) {
  // Send via GoClaw message tool or direct Telegram API
  await sendTelegramNotification(
    mapping.telegram_chat_id,
    `🚀 Your ${channel} post just went live! ${results[channel].external_url}`
  );
}