use serde::{Serialize, Serializer};
 
// Default implementation of collect_seq in serde:
// fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
// where
//     I: IntoIterator,
//     I::Item: Serialize,
// {
//     let vec: Vec<I::Item> = iter.into_iter().collect();
//     self.serialize_seq(Some(vec.len()))
//         .serialize_end()
// }
// Actually: the default creates a Vec and serializes it
 
// Problem: For large iterators, this requires allocating entire Vec
fn show_default_behavior() {
    let large_range = 0..1_000_000;
    
    // Default: collect into Vec, then serialize
    // Memory: ~8MB for the Vec, then serialization buffer
    let _json = serde_json::to_string(&large_range.collect::<Vec<_>>()).unwrap();
    
    // With collect_seq: iterate directly during serialization
    // Memory: Only serialization buffer, no intermediate Vec
}

use serde::ser::{Serialize, Serializer, SerializeSeq};
 
// Serializer::collect_seq takes an iterable and serializes it directly
fn serialize_iter_directly() {
    let numbers = 0..100;
    
    // serde_json's Serializer overrides collect_seq efficiently
    let json = serde_json::to_string(&numbers.collect::<Vec<_>>()).unwrap();
    println!("JSON: {}", json);
    // "[0,1,2,3,...,99]"
    
    // More efficient for Serializer implementations that override collect_seq:
    // Elements are serialized as they're iterated, no intermediate Vec
}

use serde::ser::{self, Serializer, SerializeSeq};
use std::io::Write;
 
// Simplified example: a serializer that writes directly to output
struct DirectSerializer<W: Write> {
    writer: W,
}
 
impl<W: Write> Serializer for DirectSerializer<W> {
    type Ok = ();
    type Error = std::io::Error;
    
    // ... other required types and methods ...
    
    // Efficient collect_seq: iterate and serialize each element
    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        I::Item: ser::Serialize,
    {
        let mut seq = self.serialize_seq(None)?;
        for item in iter {
            seq.serialize_element(&item)?;
        }
        seq.end()
    }
    
    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        // Write opening bracket
        write!(self.writer, "[")?;
        Ok(DirectSerializeSeq { writer: self.writer, first: true })
    }
}
 
struct DirectSerializeSeq<W: Write> {
    writer: W,
    first: bool,
}
 
impl<W: Write> SerializeSeq for DirectSerializeSeq<W> {
    type Ok = ();
    type Error = std::io::Error;
    
    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        if !self.first {
            write!(self.writer, ",")?;
        }
        self.first = false;
        // Serialize value directly
        value.serialize(DirectSerializer { writer: &mut self.writer })?;
        Ok(())
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        write!(self.writer, "]")?;
        Ok(())
    }
}

use serde::Serialize;
 
fn memory_comparison() {
    // Without collect_seq (naive approach):
    fn serialize_iter_naive<S, I>(iter: I) -> Result<String, S::Error>
    where
        S: serde::Serializer,
        I: IntoIterator,
        I::Item: Serialize,
    {
        // Step 1: Collect all items into Vec
        // Memory: O(n) for the Vec
        let vec: Vec<_> = iter.into_iter().collect();
        
        // Step 2: Serialize Vec
        // Memory: Additional buffer for serialized output
        serde_json::to_string(&vec).map_err(|_| unreachable!())
    }
    
    // With collect_seq (efficient approach):
    fn serialize_iter_efficient<I>(iter: I) -> String
    where
        I: IntoIterator,
        I::Item: Serialize,
    {
        // Elements serialized during iteration
        // Memory: Only the output buffer
        // No intermediate Vec
        let mut buffer = Vec::new();
        let serializer = serde_json::Serializer::new(&mut buffer);
        serde::ser::SerializeSeq::end(
            &mut serializer.serialize_seq(None).unwrap()
        ).unwrap();
        
        // serde_json internally uses collect_seq efficiently
        // when serializing iterators
        String::from_utf8(buffer).unwrap()
    }
    
    // For 1 million integers:
    // Naive: ~8MB Vec + ~6MB JSON buffer
    // Efficient: ~6MB JSON buffer only
}

use serde::Serialize;
 
fn serialize_range() {
    // Range doesn't implement Serialize directly
    // But can be serialized via collect_seq
    
    let range = 0..1000;
    
    // Collecting range into Vec first (inefficient):
    let vec: Vec<i32> = range.clone().collect();
    let json1 = serde_json::to_string(&vec).unwrap();
    
    // Using iterator serialization (efficient):
    // serde_json handles this via collect_seq internally
    let json2 = serde_json::to_string(&range.collect::<Vec<_>>()).unwrap();
    
    // More direct: serialize iterator directly
    // This is what serde_json does with collect_seq optimization
    
    // Result: Same JSON, but collect_seq avoids intermediate Vec
    // when the serializer implements it efficiently
}

use serde::{Serialize, Serializer, ser::SerializeSeq};
 
// Custom collection that wants efficient serialization
struct LazySequence<T> {
    start: T,
    end: T,
}
 
impl<T> Serialize for LazySequence<T>
where
    T: Clone + PartialOrd + Serialize + std::ops::Add<i32, Output = T> + IntoIterator,
    T::Item: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Create iterator and use collect_seq
        let iter = self.start.clone()..self.end.clone();
        serializer.collect_seq(iter)
    }
}
 
fn custom_serialization() {
    let lazy = LazySequence { start: 0, end: 10 };
    let json = serde_json::to_string(&lazy).unwrap();
    println!("JSON: {}", json);
    // "[0,1,2,3,4,5,6,7,8,9]"
}

use serde::{Serialize, Serializer, ser::SerializeSeq};
 
// serialize_seq: You manually manage the sequence
fn manual_serialize_seq<S: Serializer>(items: &[i32], serializer: S) -> Result<S::Ok, S::Error> {
    let mut seq = serializer.serialize_seq(Some(items.len()))?;
    for item in items {
        seq.serialize_element(item)?;
    }
    seq.end()
}
 
// collect_seq: Serializer manages iteration
fn with_collect_seq<S: Serializer, I>(iter: I, serializer: S) -> Result<S::Ok, S::Error>
where
    I: IntoIterator,
    I::Item: Serialize,
{
    serializer.collect_seq(iter)
}
 
fn comparison() {
    let items = vec
![1, 2, 3, 4, 5];
 
    // Both produce equivalent output, but:
    // - serialize_seq: You control iteration
    // - collect_seq: Serializer controls iteration
    
    // serialize_seq is useful when:
    // - You need custom logic between elements
    // - Elements come from different sources
    // - You know the length upfront
    
    // collect_seq is useful when:
    // - You have an iterator
    // - Serializer can optimize (no intermediate Vec)
    // - You want simpler code
}

use serde::ser::{self, Serializer, SerializeSeq};
use std::io::{self, Write};
 
// A JSON serializer that efficiently handles collect_seq
struct EfficientJsonSerializer<W: Write> {
    writer: W,
}
 
impl<W: Write> Serializer for EfficientJsonSerializer<W> {
    type Ok = ();
    type Error = io::Error;
    type SerializeSeq = JsonSeqSerializer<W>;
    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
    
    // Efficient collect_seq: iterate once, no collection
    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        I::Item: ser::Serialize,
    {
        // Write opening bracket
        write!(self.writer, "[")?;
        
        let mut first = true;
        for item in iter {
            if !first {
                write!(self.writer, ",")?;
            }
            first = false;
            
            // Serialize each item directly
            item.serialize(EfficientJsonSerializer { writer: &mut self.writer })?;
        }
        
        // Write closing bracket
        write!(self.writer, "]")?;
        Ok(())
    }
    
    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        write!(self.writer, "[")?;
        Ok(JsonSeqSerializer { writer: self.writer, first: true })
    }
    
    // ... other methods would use ser::Impossible for unsupported types ...
}
 
struct JsonSeqSerializer<W: Write> {
    writer: W,
    first: bool,
}
 
impl<W: Write> SerializeSeq for JsonSeqSerializer<W> {
    type Ok = ();
    type Error = io::Error;
    
    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        if !self.first {
            write!(self.writer, ",")?;
        }
        self.first = false;
        value.serialize(EfficientJsonSerializer { writer: &mut self.writer })?;
        Ok(())
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        write!(self.writer, "]")?;
        Ok(())
    }
}
 
fn use_efficient_serializer() {
    let mut output = Vec::new();
    let serializer = EfficientJsonSerializer { writer: &mut output };
    
    // This will iterate directly without collecting into Vec
    let numbers = 0..1000;
    serializer.collect_seq(numbers).unwrap();
    
    println!("Output: {}", String::from_utf8_lossy(&output));
}

use serde::Serializer;
 
// What the default collect_seq does (conceptually):
// fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
// where
//     I: IntoIterator,
//     I::Item: Serialize,
// {
//     // Collect everything into Vec
//     let vec: Vec<I::Item> = iter.into_iter().collect();
//     
//     // Then serialize the Vec
//     self.serialize_seq(Some(vec.len()))?
//         .serialize_end()
// }
// Note: Actual implementation may vary slightly
 
// This means: if a serializer doesn't override collect_seq,
// you still get correct output, but with extra allocation
 
// Serializers that care about efficiency override collect_seq:
// - serde_json
// - serde_cbor
// - Most popular formats

use serde::Serialize;
use serde_json;
 
fn stream_large_dataset() {
    // Simulating a large data source that shouldn't fit in memory
    let large_iterator = (0..1_000_000).map(|i| DataPoint {
        id: i,
        value: i * 2,
        label: format!("item_{}", i),
    });
    
    // Without collect_seq optimization:
    // 1. Collect all 1M items into Vec (huge memory)
    // 2. Serialize Vec (large buffer)
    // Total memory: Vec + buffer
    
    // With collect_seq (serde_json):
    // 1. Write opening bracket
    // 2. Iterate, serialize each item directly to buffer
    // 3. Write closing bracket
    // Total memory: Just the buffer
    
    let json = serde_json::to_string(&large_iterator.collect::<Vec<_>>()).unwrap();
    // serde_json internally uses efficient collect_seq
    
    println!("JSON length: {} bytes", json.len());
}
 
#[derive(Serialize)]
struct DataPoint {
    id: u32,
    value: u32,
    label: String,
}

use serde::Serialize;
use std::time::Instant;
 
fn benchmark_collect_seq() {
    const N: usize = 100_000;
    
    // Approach 1: Collect first, then serialize (inefficient)
    let start = Instant::now();
    let vec: Vec<i32> = (0..N as i32).collect();
    let json1 = serde_json::to_string(&vec).unwrap();
    let collect_time = start.elapsed();
    
    // Approach 2: serialize_seq (manual, efficient)
    let start = Instant::now();
    let mut buffer = Vec::new();
    {
        let mut ser = serde_json::Serializer::new(&mut buffer);
        let mut seq = ser.serialize_seq(Some(N)).unwrap();
        for i in 0..N as i32 {
            seq.serialize_element(&i).unwrap();
        }
        seq.end().unwrap();
    }
    let seq_time = start.elapsed();
    
    // Approach 3: collect_seq via efficient serializer (serde_json)
    // serde_json::Serializer implements collect_seq efficiently
    // This is what happens when you serialize iterators through serde_json
    
    println!("Collect-first: {:?}", collect_time);
    println!("Serialize-seq: {:?}", seq_time);
    // Results depend on serializer's collect_seq implementation
    
    // Key insight: collect_seq in serde_json achieves similar
    // performance to manual serialize_seq, avoiding Vec allocation
}

use serde::{Serialize, Serializer};
 
// Implementing Serialize using collect_seq
struct Container<T> {
    items: Vec<T>,
}
 
impl<T> Serialize for Container<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Option 1: Serialize Vec directly
        // self.items.serialize(serializer)
        
        // Option 2: Use collect_seq with iterator
        // Allows serializer to optimize
        serializer.collect_seq(self.items.iter())
    }
}
 
// Another example: custom iteration logic
struct FilteredSequence<'a, T> {
    items: &'a [T],
    predicate: fn(&T) -> bool,
}
 
impl<'a, T> Serialize for FilteredSequence<'a, T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Use collect_seq to serialize only matching items
        // No intermediate Vec needed
        serializer.collect_seq(
            self.items.iter().filter(|item| (self.predicate)(item))
        )
    }
}
 
fn filtered_example() {
    let items = vec
![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let filtered = FilteredSequence {
        items: &items,
        predicate: |x| x % 2 == 0,
    };
    
    let json = serde_json::to_string(&filtered).unwrap();
    println!("Filtered: {}", json);
    // Only even numbers serialized
}

// Serializers should override collect_seq when:
// 1. They can write directly to output without buffering
// 2. The format supports streaming sequences
// 3. Memory efficiency matters
 
// Example: A binary format that writes length prefix
// can still benefit from collect_seq if it:
// - Buffers elements temporarily to count
// - Or writes streaming format without length
 
// Example: A format that supports streaming
// (like newline-delimited JSON)
struct NdJsonSerializer<W: std::io::Write> {
    writer: W,
}
 
impl<W: std::io::Write> Serializer for NdJsonSerializer<W> {
    // ... other methods ...
    
    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        I::Item: serde::Serialize,
    {
        // ND-JSON: each element on its own line
        // No need for brackets, just iterate and write
        for item in iter {
            item.serialize(NdJsonSerializer { writer: &mut self.writer })?;
            writeln!(self.writer)?;
        }
        Ok(())
    }
}

use serde::Serializer;
 
// Similar methods exist for maps and tuples:
 
// collect_map: Serialize map-like types without intermediate BTreeMap/HashMap
// fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
// where
//     K: Serialize,
//     V: Serialize,
//     I: IntoIterator<Item = (K, V)>,
 
// collect_tuple: Serialize tuple-like types without intermediate tuple
// fn collect_tuple<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
// where
//     I: IntoIterator,
//     I::Item: Serialize,
 
fn related_methods() {
    // These follow the same pattern as collect_seq:
    // - Default: collect into intermediate structure
    // - Efficient override: iterate directly
}

// Default behavior (if not overridden):
// 1. Collect iterator into Vec
// 2. Serialize the Vec
// Memory: O(n) for intermediate Vec
 
// Efficient behavior (serde_json, etc.):
// 1. Open sequence (write "[")
// 2. Iterate, serialize each element directly
// 3. Close sequence (write "]")
// Memory: O(1) - no intermediate Vec

// Use collect_seq when:
// - Serializing iterators (ranges, filtered collections, etc.)
// - Implementing Serialize for custom iterable types
// - Working with lazy sequences
// - Memory efficiency matters
 
// Use serialize_seq directly when:
// - You need manual control over serialization
// - Elements come from non-iterator sources
// - You have custom element processing

// For serializer authors:
impl<S: Serializer> Serializer for MySerializer {
    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        I::Item: Serialize,
    {
        // Efficient: iterate once, serialize directly
        let mut seq = self.serialize_seq(None)?;
        for item in iter {
            seq.serialize_element(&item)?;
        }
        seq.end()
        
        // NOT: collect into Vec first
        // let vec: Vec<_> = iter.collect();
        // self.serialize_seq(Some(vec.len()))?...
    }
}