#![cfg(feature = "publisher")]

use chrono::NaiveDate;
use tavern::{Adventurer, Legend, Lore, Story, Tale, Tavern};



fn generate_tavern() -> Tavern
{
   let legend: Legend = Legend
   {
      profile: String::from("https://cybermages.tech/about/myrddin"),
      image: String::from("https://cybermages.tech/about/myrddin/pic"),
      blurb: String::from("I love code!")
   };

   let author: Adventurer = Adventurer
   {
      name: String::from("Jason Smith"),
      handle: String::from("myrddin"),
      legend: legend
   };

   let lore: Lore = Lore
   {
      title: String::from("Test post"),
      slug: String::from("test_post"),
      author: author.handle.clone(),
      summary: String::from("The Moon is made of cheese!"),
      tags: vec![String::from("Space"), String::from("Cheese")],
      publish_date:
         NaiveDate::from_ymd_opt(2025, 12, 25).unwrap()
                                              .and_hms_opt(13, 10, 41)
                                              .unwrap()
   };

   let tale: Tale = Tale
   {
      lore: lore,
      story: Story::File(std::path::PathBuf::from("posts/test_post.md"))
   };

   Tavern { title: String::from("Runes & Ramblings"),
            description: String::from("Join software engineer Jason Smith \
                                       on his Rust programming journey. \
                                       Explore program design, tech \
                                       stacks, and more on this blog from \
                                       CybeMages, LLC."),
            tales: vec![tale],
            authors: vec![author] }
}

fn create_temp_file<S>(filename: S) -> std::path::PathBuf
   where S: AsRef<std::path::Path>
{
   let mut path = std::env::temp_dir();
   path.push(filename);

   path
}

fn cleanup_temp_file(path: &std::path::PathBuf)
{
   if path.exists()
   {
      let _ = std::fs::remove_file(path);
   }
}


#[test]
fn to_file()
{
   let tavern = generate_tavern();

   let toml_string = toml::to_string_pretty(&tavern).expect("Serialization \
                                                             to TOML should \
                                                             succeed");

   // Save the TOML to a temporary file.
   let path = create_temp_file("tavern_test_to.toml");
   std::fs::write(&path, &toml_string).expect("Failed to write TOML to file");

   cleanup_temp_file(&path);
}

#[test]
fn from_file()
{
   let tavern = generate_tavern();

   let toml_string = toml::to_string_pretty(&tavern).expect("Serialization \
                                                             to TOML should \
                                                             succeed");

   // Save the TOML to a temporary file.
   let path = create_temp_file("tavern_test_from.toml");
   std::fs::write(&path, &toml_string).expect("Failed to write TOML to file");

   // Read the previously written TOML file
   let toml_data =
      std::fs::read_to_string(&path).expect("Failed to read TOML file");

   // Deserialize it
   let tavern: Tavern =
      toml::from_str(&toml_data).expect("Failed to parse TOML");

   // Assert some known values to make this a real test
   let tale = &tavern.tales[0];
   assert_eq!(tale.lore.title, "Test post");
   assert_eq!(tale.lore.slug, "test_post");
   assert_eq!(tale.lore.author, "myrddin");

   cleanup_temp_file(&path);
}
