// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use anyhow;
use json5format::*;
use std::mem::discriminant;

/// A recursive function that takes in two references to `json5format::Value`s,
/// and modifies the second one to incorporate comments contained in the first.
/// The function does a depth-first search of the JSON5 tree structure,
/// transferring comments for a value X in `json5_val` to a value Y in
/// `jq_output_val` if both a) X and Y have the same path from the root of the
/// tree. b) X and Y are the same `json5format::Value` variant. In particular, a
/// comment attached to X does NOT transfer over to anything if X's path from the
/// root does not exist in `jq_output_val`, or if the path points to a different
/// `Value` variant. For example, comments do not transfer from an object to an
/// array, even if they have the same path from root. Specific examples are
/// provided in tests.
///
/// `json5_val` is the original value containing the comments to be transferred.
/// `jq_output_val` is presumed to reference a comment-less value generated from
/// stdout from a jq call. While it may actually contain comments, it is
/// presumed that it will not. If it does, many will likely be deleted,
/// especially if it is similar in structure to `json5_val`.
fn fill_comments_helper(json5_val: &Value, jq_output_val: &mut Value) -> Result<(), anyhow::Error> {
    match json5_val {
        Value::Object { val, comments } => {
            match jq_output_val {
                Value::Object { val: out_val, comments: out_comments } => {
                    *out_comments = comments.clone();
                    *out_val.trailing_comments_mut() = val.trailing_comments().clone();
                    let mut out_properties : Vec<_> = out_val.properties_mut().collect();
                    for property in val.properties() {
                        let index = out_properties
                            .iter()
                            .position(|p_output| p_output.name() == property.name());
                        if let Some(i) = index {
                            //Using two nested conditionals due to compiler bug when using if-let syntax
                            if discriminant(&*property.value())
                                == discriminant(&*out_properties[i].value())
                            {
                                fill_comments_helper(
                                    &property.value(),
                                    &mut out_properties[i].value_mut(),
                                )?;
                            }
                        }
                    }
                }
                _ => {
                    return Err(anyhow::anyhow!(
                      "fill_comments_helper was called on mismatched Value variants.\njson5_val was: {:?}\njq_output_val was: {:?}",
                      json5_val,
                      jq_output_val
                  ))
                }
            }
        }
        Value::Array { val, comments } => {
            match jq_output_val {
                Value::Array { val: out_val, comments: out_comments } => {
                    *out_comments = comments.clone();
                    *out_val.trailing_comments_mut() = val.trailing_comments().clone();
                    for (sub_val, mut out_sub_val) in val.items().zip(out_val.items_mut()) {
                        if discriminant(&(*sub_val)) == discriminant(&(*out_sub_val))
                        {
                            fill_comments_helper(
                                &sub_val,
                                &mut out_sub_val,
                            )?;
                        }
                    }
                }
                _ => {
                    return Err(anyhow::anyhow!(
                      "fill_comments_helper was called on mismatched Value variants.\njson5_val was: {:?}\njq_output_val was: {:?}",
                      json5_val,
                      jq_output_val
                  ))
                }
            }
        }
        Value::Primitive { comments, .. } => match jq_output_val {
            Value::Primitive { comments: out_comments, .. } => {
                *out_comments = comments.clone();
            }
            _ => {
                return Err(anyhow::anyhow!(
                    "fill_comments_helper was called on mismatched Value variants.\njson5_val was: {:?}\njq_output_val was: {:?}",
                    json5_val,
                    jq_output_val
                ))
            }
        },
    };
    Ok(())
}

/// Transfers the comments at the bottom of the document below the json5 object
/// and calls `fill_comments_helper` to transfer the rest of the comments.
#[inline]
pub(crate) fn fill_comments(
    json5_content: &Array,
    jq_output_content: &mut Array,
) -> Result<(), anyhow::Error> {
    *jq_output_content.trailing_comments_mut() = json5_content.trailing_comments().clone();

    fill_comments_helper(
        &json5_content.items().next().unwrap(),
        &mut jq_output_content.items_mut().next().unwrap(),
    )
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn fill_comments_handles_changed_field_type() {
        let json5_original = String::from(
            r##"{
    // Foo
    "offer": [
        {
            // Bar
            "directory": "input",
            "from": "self",
            // Baz
            "to": [ "#pwrbtn-monitor" ]
        },
        {
            "protocol": "fuchsia.hardware.power.statecontrol.Admin",
            "from": "self",
            "to": [ "#pwrbtn-monitor" ]
        }
    ]
}"##,
        );
        let json5_target = String::from(
            r##"{
    "offer": [
        {
            "directory": "input",
            "from": "self",
            "to": "#pwrbtn-monitor"
        },
        {
            "protocol": "fuchsia.hardware.power.statecontrol.Admin",
            "from": "self",
            "to": "#pwrbtn-monitor"
        }
    ]
}"##,
        );
        let expected_outcome = String::from(
            r##"{
    // Foo
    "offer": [
        {
            // Bar
            "directory": "input",
            "from": "self",
            "to": "#pwrbtn-monitor"
        },
        {
            "protocol": "fuchsia.hardware.power.statecontrol.Admin",
            "from": "self",
            "to": "#pwrbtn-monitor"
        }
    ]
}"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();
        let parsed_expected_outcome =
            json5format::ParsedDocument::from_str(&expected_outcome[..], None).unwrap();
        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();

        assert_eq!(
            format.to_string(&parsed_expected_outcome).unwrap(),
            format.to_string(&parsed_json5_target).unwrap()
        );
    }
    #[test]
    fn simple_transfer_object1() {
        let json5_original = String::from(
            r##"
//Comment at
//Beginning of
//Document

{
  // Foo
  hello: 'world',

  // Bar
  yoinks: "everybody", //Baz


  //Contained Comment (at end of object)
}
"##,
        );
        let json5_target = String::from(
            r##"
{
  hello: 'world',

  yoinks: "everybody",
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();

        assert_eq!(
            format.to_string(&parsed_json5_original).unwrap(),
            format.to_string(&parsed_json5_target).unwrap()
        );
    }
    #[test]
    fn simple_transfer_object2() {
        let json5_original = String::from(
            r##"
//Comment at
//Beginning of
//Document

{
  // Foo
  hello: 'world',

  // Bar
  yoinks: "everybody", //Baz


  //Contained Comment (at end of object)
}
"##,
        );
        let json5_target = String::from(
            r##"
//All
{
  //these
  hello: 'world', //comments
  //will
  yoinks: "everybody", //be
  //deleted
  //by fill_comments
  //since they are attached to nodes that correspond to a path in the original json5.
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();

        assert_eq!(
            format.to_string(&parsed_json5_original).unwrap(),
            format.to_string(&parsed_json5_target).unwrap()
        );
    }

    #[test]
    fn simple_transfer_object3() {
        let json5_original = String::from(
            r##"
//Comment at
//Beginning of
//Document

{
  // Foo
  hello: 'world',

  // Bar
  yoinks: 'everybody', //Baz

  //This comment will be deleted since the field does not appear in the target
  removed_in_target: "Away I must go!",

  //Contained Comment (at end of object)
}
"##,
        );
        let json5_target = String::from(
            r##"
{
  hello: 'world',

  yoinks: 'everybody',

  //This comment will stay, since there is no node in the original that overrides this node.
  addition_in_target: 'Nice to meet you!',
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();
        let expected_outcome = String::from(
            r##"
//Comment at
//Beginning of
//Document

{
  // Foo
  hello: 'world',

  // Bar
  yoinks: 'everybody', //Baz

  //This comment will stay, since there is no node in the original that overrides this node.
  addition_in_target: 'Nice to meet you!',

  //Contained Comment (at end of object)
}
"##,
        );
        assert_eq!(
            format.to_string(&parsed_json5_target).unwrap(),
            format
                .to_string(
                    &json5format::ParsedDocument::from_str(&expected_outcome[..], None).unwrap()
                )
                .unwrap()
        );
    }
    #[test]
    fn simple_transfer_array() {
        let json5_original = String::from(
            r##"
{
  "array": [
    //First Comment.
    1,
    //Second Comment.
    2
    //Contained Comment (end of array).
  ]
}
"##,
        );
        let json5_target = String::from(
            r##"
{
  "array": [
    1,
    2,
    3
  ]
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();
        let expected_outcome = String::from(
            r##"
{
  "array": [
    //First Comment.
    1,
    //Second Comment.
    2,
    3
    //Contained Comment (end of array).
  ]
}
"##,
        );
        assert_eq!(
            format.to_string(&parsed_json5_target).unwrap(),
            format
                .to_string(
                    &json5format::ParsedDocument::from_str(&expected_outcome[..], None).unwrap()
                )
                .unwrap()
        );
    }
    #[test]
    #[ignore]
    /*
    This test fails with the current implementation, and is included to show an
    example of what fill_comments does *not* do. When transferring comments
    between arrays, a deleted entry shifts the entries that come after it. This
    presents certain issues.

    For example, if a comment is attached to a value at index 1 and the value at
    index 0 is deleted in the target array, fill_comments does *not* transfer
    the comment to index 0, as one might desire. Instead, it transfers it to
    the value at index 1 (or doesn't transfer it at all if index 1 does
    not exist in the target).
    */
    fn transfer_array_deleted_value() {
        let json5_original = String::from(
            r##"
{
  "array": [
    //First Comment.
    1,
    //Second Comment.
    2
  ]
}
"##,
        );
        let json5_target = String::from(
            r##"
{
  "array": [
    2,
  ]
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();
        let expected_outcome = String::from(
            r##"
{
  "array": [
    //Second Comment.
    2,
  ]
}
"##,
        );
        assert_eq!(
            format.to_string(&parsed_json5_target).unwrap(),
            format
                .to_string(
                    &json5format::ParsedDocument::from_str(&expected_outcome[..], None).unwrap()
                )
                .unwrap()
        );
    }
    #[test]
    fn recursive_transfer() {
        let json5_original = String::from(
            r##"
//Comment at beginning.
{
  //Foo1
  "Foo1": "Bar1",
  //Array
  "arr": [
    //Primitive in array. Even though the actual value changes, this comment
    //gets carried over since the same path from root exists in the target.
    "Baz",
    //Object in array
    {
      //Foo2
      "Foo2": "Bar2",
      //Field entry not present in target. This comment will not carry over.
      "deleted_field2": "bye, again!"
      //Comment at end of second object.
    }
    //Comment at end of array.
  ],
  //Field entry not present in target. This comment will not carry over.
  "deleted_field1": "bye, world!"
  //Comment at end of first object.
}
// Comment at end of document.
"##,
        );
        let json5_target = String::from(
            r##"
//This comment will be overriden since its path exists in the original.
{
  //This comment will also be overriden.
  "Foo1": "Bar1",
  //This comment will also be overriden.
  "arr": [
    //This comment will also be overriden (even though the value changed).
    "BazBaz",
    //This comment will also be overriden.
    {
      //This comment will also be overriden.
      "Foo2": "Bar2",
      //Comment on new_field2 (will stay).
      "new_field2": "hello, again!"
    },
    //Comment on new array entry, 0 (will stay).
    0
  ],
  //Comment on new_field1 (will stay).
  "new_field1": "hello, world!"
}
"##,
        );
        let parsed_json5_original =
            json5format::ParsedDocument::from_str(&json5_original[..], None).unwrap();
        let mut parsed_json5_target =
            json5format::ParsedDocument::from_str(&json5_target[..], None).unwrap();

        fill_comments(&parsed_json5_original.content, &mut parsed_json5_target.content).unwrap();

        let format = json5format::Json5Format::new().unwrap();
        let expected_outcome = String::from(
            r##"
//Comment at beginning.
{
  //Foo1
  "Foo1": "Bar1",
  //Array
  "arr": [
    //Primitive in array. Even though the actual value changes, this comment
    //gets carried over since the same path from root exists in the target.
    "BazBaz",
    //Object in array
    {
      //Foo2
      "Foo2": "Bar2",
      //Comment on new_field2 (will stay).
      "new_field2": "hello, again!"
      //Comment at end of second object.
    },
    //Comment on new array entry, 0 (will stay).
    0
    //Comment at end of array.
  ],
  //Comment on new_field1 (will stay).
  "new_field1": "hello, world!"
  //Comment at end of first object.
}
// Comment at end of document.
"##,
        );
        assert_eq!(
            format.to_string(&parsed_json5_target).unwrap(),
            format
                .to_string(
                    &json5format::ParsedDocument::from_str(&expected_outcome[..], None).unwrap()
                )
                .unwrap()
        );
    }
}