use serde::ser::{Serialize, SerializeMap, Serializer};
use std::collections::HashMap;
 
// Implementing Serialize for a custom map type
impl Serialize for HashMap<String, i32> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // serialize_map returns a SerializeMap
        let mut map = serializer.serialize_map(Some(self.len()))?;
        
        for (k, v) in self {
            // Option 1: Using serialize_entry (convenience)
            map.serialize_entry(k, v)?;
        }
        
        map.end()
    }
}

use serde::ser::{Serialize, SerializeMap, Serializer};
use serde_json::json;
 
struct MyMap {
    data: Vec<(String, i32)>,
}
 
impl Serialize for MyMap {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.data.len()))?;
        
        // Approach 1: serialize_entry (convenience method)
        for (key, value) in &self.data {
            map.serialize_entry(key, value)?;
        }
        
        map.end()
    }
}
 
// Equivalent implementation using serialize_key + serialize_value:
 
impl Serialize for MyMap {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.data.len()))?;
        
        // Approach 2: serialize_key then serialize_value
        for (key, value) in &self.data {
            map.serialize_key(key)?;
            map.serialize_value(value)?;
        }
        
        map.end()
    }
}
 
fn main() {
    let my_map = MyMap {
        data: vec![
            ("a".to_string(), 1),
            ("b".to_string(), 2),
        ],
    };
    
    // Both produce identical JSON:
    // {"a":1,"b":2}
    let json = serde_json::to_string(&my_map).unwrap();
    println!("{}", json);
}

use serde::ser::{SerializeMap, Error};
 
// Conceptual default implementation of serialize_entry:
 
// trait SerializeMap {
//     fn serialize_entry<K: ?Sized, V: ?Sized>(
//         &mut self,
//         key: &K,
//         value: &V,
//     ) -> Result<(), Self::Error>
//     where
//         K: Serialize,
//         V: Serialize,
//     {
//         // Default implementation: call both methods
//         self.serialize_key(key)?;
//         self.serialize_value(value)
//     }
// }
 
// This is the default behavior - any SerializeMap implementation
// can override it, but the default just calls the two methods.
 
// For most formats (JSON, bincode, etc.), there's no difference.
// The separation exists for formats that need it.

use serde::ser::{Serialize, SerializeMap, Serializer, Error};
use std::collections::HashMap;
 
// Some formats need to describe the structure between key and value
 
// Hypothetical self-describing format serializer:
 
struct SelfDescribingMap {
    // Tracks state: are we expecting a key or value?
    expecting_key: bool,
    entries: Vec<(String, String)>,
}
 
impl SerializeMap for SelfDescribingMap {
    type Ok = String;
    type Error = serde_json::Error;
    
    fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<(), Self::Error>
    where
        K: Serialize,
    {
        // In a self-describing format, we might need to:
        // - Write field name metadata
        // - Track that we're now expecting a value
        // - Store the key for later
        
        self.expecting_key = false;
        // Store key somehow...
        Ok(())
    }
    
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Self::Error>
    where
        V: Serialize,
    {
        // Now we know the key and can:
        // - Write key-value pair with type information
        // - Emit type descriptors before the value
        
        self.expecting_key = true;
        Ok(())
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        // Build final output
        Ok("{}".to_string())
    }
    
    // serialize_entry uses default: calls serialize_key then serialize_value
    // But we COULD override it for optimization:
    
    fn serialize_entry<K: ?Sized, V: ?Sized>(
        &mut self,
        key: &K,
        value: &V,
    ) -> Result<(), Self::Error>
    where
        K: Serialize,
        V: Serialize,
    {
        // For some formats, this could be more efficient
        // because we have both key and value at once
        // (But default implementation is usually fine)
        self.serialize_key(key)?;
        self.serialize_value(value)
    }
}

use serde::ser::{Serialize, SerializeMap, Serializer};
 
// The key-value separation allows operations between them
 
struct InstrumentedSerializer<'a> {
    inner: &'a mut serde_json::Serializer<Vec<u8>>,
}
 
impl<'a> SerializeMap for InstrumentedSerializer<'a> {
    type Ok = ();
    type Error = serde_json::Error;
    
    fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<(), Self::Error>
    where
        K: Serialize,
    {
        println!("About to serialize key");
        // Could add logging, metrics, or validation here
        // self.inner.serialize_key(key)  // hypothetical
        Ok(())
    }
    
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Self::Error>
    where
        V: Serialize,
    {
        println!("About to serialize value");
        // Could transform value based on previous key
        // self.inner.serialize_value(value)  // hypothetical
        Ok(())
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        println!("Finished serializing map");
        Ok(())
    }
    
    fn serialize_entry<K: ?Sized, V: ?Sized>(
        &mut self,
        key: &K,
        value: &V,
    ) -> Result<(), Self::Error>
    where
        K: Serialize,
        V: Serialize,
    {
        // With serialize_entry, both are available at once
        // Useful for logging key-value pairs together
        println!("Serializing entry: key={:?}, value={:?}", 
                 // We can't actually print them without Serialize impls
                 // but conceptually we have both available
        );
        self.serialize_key(key)?;
        self.serialize_value(value)
    }
}

// For formats like CDDL (Concise Data Definition Language) or
// other schema-aware serializers, the separation enables:
 
// Example: A format that writes type annotations between key and value
 
use serde::ser::{SerializeMap, Serializer};
 
// Hypothetical schema-aware format:
// { "key": <type_hint> value, ... }
// Where <type_hint> is derived from the value's type
 
// With serialize_key + serialize_value:
// 1. serialize_key writes "key":
// 2. Now we can inspect what value will be serialized
// 3. serialize_value writes <type_hint> value
 
// With serialize_entry, we'd need to do both at once
// (but default implementation handles this by calling both methods)
 
// The separation is useful when:
// - The format needs to know the value before writing the key
// - The key influences how the value should be encoded
// - Type information must be interleaved
 
// In practice, most formats don't need this distinction

use serde::ser::{Serialize, SerializeMap, Serializer, Ok, Error};
use std::collections::BTreeMap;
 
// Custom serializer that logs the map structure
 
struct LoggingMapSerializer<'a, W: std::io::Write> {
    writer: &'a mut W,
    first: bool,
}
 
impl<'a, W: std::io::Write> SerializeMap for LoggingMapSerializer<'a, W> {
    type Ok = ();
    type Error = serde_json::Error;
    
    fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<(), Self::Error>
    where
        K: Serialize,
    {
        if !self.first {
            write!(self.writer, ",").map_err(Error::custom)?;
        }
        self.first = false;
        
        // In real implementation, would serialize key
        // For this example, just demonstrating the pattern
        Ok(())
    }
    
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Self::Error>
    where
        V: Serialize,
    {
        write!(self.writer, ":").map_err(Error::custom)?;
        // Would serialize value here
        Ok(())
    }
    
    fn serialize_entry<K: ?Sized, V: ?Sized>(
        &mut self,
        key: &K,
        value: &V,
    ) -> Result<(), Self::Error>
    where
        K: Serialize,
        V: Serialize,
    {
        // Could optimize by doing both at once
        // But default implementation works fine:
        self.serialize_key(key)?;
        self.serialize_value(value)
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        write!(self.writer, "}}").map_err(Error::custom)?;
        Ok(())
    }
}
 
// Note: In practice, you'd use the Serializer trait properly
// This shows the conceptual structure

use serde::ser::{Serialize, SerializeMap, Serializer};
 
// For streaming formats, the separation enables:
 
struct StreamingMapSerializer {
    key_count: usize,
    current_key: Option<String>,
}
 
impl SerializeMap for StreamingMapSerializer {
    type Ok = ();
    type Error = serde_json::Error;
    
    fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<(), Self::Error>
    where
        K: Serialize,
    {
        // For streaming, we might:
        // 1. Buffer the key
        // 2. Flush previous entry
        // 3. Start new entry
        
        // The key could be stored for use in serialize_value
        self.key_count += 1;
        // In real impl: self.current_key = Some(serialized_key)
        Ok(())
    }
    
    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Self::Error>
    where
        V: Serialize,
    {
        // Now we have both key and value
        // For streaming: flush this entry immediately
        
        // In streaming context, this separation allows:
        // - Flushing after value is known
        // - Applying streaming transformations
        // - Managing memory by not buffering entire map
        
        Ok(())
    }
    
    fn end(self) -> Result<Self::Ok, Self::Error> {
        // Finalize stream
        println!("Serialized {} entries", self.key_count);
        Ok(())
    }
}

use serde::ser::{SerializeMap, Error};
use serde_json::Error as JsonError;
 
// Error handling is identical for both approaches:
 
fn example_map_errors() {
    // serialize_entry error propagation:
    // serialize_entry(key, value)?
    // - Returns error if key serialization fails
    // - Returns error if value serialization fails
    
    // serialize_key + serialize_value error propagation:
    // serialize_key(key)?;       // Returns error if key fails
    // serialize_value(value)?;   // Returns error if value fails
    
    // The difference: with separate calls, you can:
    // - Handle key errors differently from value errors
    // - Provide more specific error context
    // - Retry or transform between key and value
    
    // Example:
    // match map.serialize_key(&key) {
    //     Ok(()) => {
    //         // Key serialized successfully, now serialize value
    //         map.serialize_value(&value)?;
    //     }
    //     Err(e) => {
    //         // Could log specific key error, try alternative, etc.
    //         println!("Failed to serialize key: {}", e);
    //         return Err(e);
    //     }
    // }
}

use serde::ser::{Serialize, SerializeMap, Serializer};
 
// Performance difference is minimal in most cases:
 
struct MyData {
    items: Vec<(String, String)>,
}
 
impl Serialize for MyData {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.items.len()))?;
        
        // Option 1: serialize_entry
        // - Single method call per entry
        // - Slightly cleaner code
        // - Default impl calls serialize_key + serialize_value anyway
        
        for (k, v) in &self.items {
            map.serialize_entry(k, v)?;
        }
        
        // Option 2: serialize_key + serialize_value
        // - Two method calls per entry
        // - More verbose
        // - Same performance for most formats
        
        // for (k, v) in &self.items {
        //     map.serialize_key(k)?;
        //     map.serialize_value(v)?;
        // }
        
        map.end()
    }
}
 
// For JSON, bincode, etc.: no measurable difference
// For custom formats: may have format-specific optimizations
 
// The main reason to use serialize_entry: cleaner code
// The main reason to use serialize_key/value: need operations between them

use serde::ser::{Serialize, SerializeMap, Serializer};
use std::collections::BTreeMap;
 
// A custom map type with metadata
 
#[derive(Debug)]
struct TaggedMap {
    tag: String,
    entries: BTreeMap<String, String>,
}
 
impl Serialize for TaggedMap {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Use serialize_map for map-like serialization
        // Include the tag as a special field
        
        let mut map = serializer.serialize_map(Some(self.entries.len() + 1))?;
        
        // First, serialize the tag
        map.serialize_entry("__tag", &self.tag)?;
        
        // Then serialize all entries
        for (key, value) in &self.entries {
            map.serialize_entry(key, value)?;
        }
        
        map.end()
    }
}
 
// Alternative with serialize_key/value (no functional difference here):
 
impl Serialize for TaggedMap {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.entries.len() + 1))?;
        
        // Tag first
        map.serialize_key("__tag")?;
        map.serialize_value(&self.tag)?;
        
        // Entries
        for (key, value) in &self.entries {
            map.serialize_key(key)?;
            map.serialize_value(value)?;
        }
        
        map.end()
    }
}
 
fn main() {
    let tagged = TaggedMap {
        tag: "user_profile".to_string(),
        entries: vec![
            ("name".to_string(), "Alice".to_string()),
            ("email".to_string(), "alice@example.com".to_string()),
        ].into_iter().collect(),
    };
    
    let json = serde_json::to_string(&tagged).unwrap();
    println!("{}", json);
    // {"__tag":"user_profile","email":"alice@example.com","name":"Alice"}
}

// The SerializeMap trait (from serde::ser):
 
// pub trait SerializeMap {
//     type Ok;
//     type Error: Error;
//     
//     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
//     where
//         T: Serialize;
//     
//     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
//     where
//         T: Serialize;
//     
//     fn end(self) -> Result<Self::Ok, Self::Error>;
//     
//     fn serialize_entry<K: ?Sized, V: ?Sized>(
//         &mut self,
//         key: &K,
//         value: &V,
//     ) -> Result<(), Self::Error>
//     where
//         K: Serialize,
//         V: Serialize,
//     {
//         // Default implementation:
//         self.serialize_key(key)?;
//         self.serialize_value(value)
//     }
// }
 
// Key points:
// - serialize_key: Serialize just the key, prepare for value
// - serialize_value: Serialize the value (key must have been serialized)
// - serialize_entry: Default impl calls both; can be overridden
// - end: Finalize the map, return the output