use crate::{
    Apply, Clipboard, CommandError, Destination, FileId, Place, Selection, State, TrackId, transfer,
};

/// Where moved elements go: a list of the file tree, and the position in it. The position is
/// counted among the elements of the list that are not moved, like the position of a dragged
/// element in the list it is dropped in.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MoveTarget {
    /// The list of files.
    Files { index: usize },
    /// The tracks of a file.
    Tracks { file_id: FileId, index: usize },
    /// The segments of a track.
    Segments {
        file_id: FileId,
        trk_id: TrackId,
        index: usize,
    },
    /// The waypoints of a file.
    Waypoints { file_id: FileId, index: usize },
}

/// Moves elements to a place of the file tree (what drag and drop does), with their ids. The
/// moved elements are selected.
///
/// What can go where:
/// - files: among the files;
/// - tracks: among the files (each track becomes a file), or among the tracks of a file;
/// - segments: among the files (each segment becomes a file), among the tracks of a file (each
///   segment becomes a track), or among the segments of a track;
/// - waypoints, or all the waypoints of a file (the waypoints node): among the waypoints of a
///   file.
#[derive(Debug)]
pub struct Move {
    pub what: Selection,
    pub to: MoveTarget,
}

impl From<MoveTarget> for Destination {
    fn from(target: MoveTarget) -> Self {
        match target {
            MoveTarget::Files { index } => Destination::Files(Place::Index(index)),
            MoveTarget::Tracks { file_id, index } => {
                Destination::Tracks(file_id, Place::Index(index))
            }
            MoveTarget::Segments {
                file_id,
                trk_id,
                index,
            } => Destination::Segments(file_id, trk_id, Place::Index(index)),
            MoveTarget::Waypoints { file_id, index } => {
                Destination::Waypoints(file_id, Place::Index(index))
            }
        }
    }
}

impl Apply for Move {
    fn apply(self, state: &mut State) -> Result<(), CommandError> {
        let clipboard = Clipboard::new(&self.what, state.files, &state.order.0, true)
            .ok_or(CommandError::NothingToDo)?;
        *state.selection = transfer(state, &clipboard.content, true, self.to.into())?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::rc::Rc;

    use crate::{
        File, Track, TrackInfo, TrackSegment, TrackSegmentId, Waypoint, WaypointChunk, WaypointId,
        Waypoints, engine::command::fixture::Fixture, new_file, waypoint_ids,
    };

    use super::*;

    /// A file with the given tracks (name, number of segments) and number of waypoints.
    fn file(name: &str, tracks: &[(&str, usize)], waypoints: usize) -> File {
        let mut file = new_file(
            name,
            tracks
                .iter()
                .map(|(name, segments)| Track {
                    info: TrackInfo {
                        name: Some((*name).to_owned()),
                        ..Default::default()
                    },
                    trkseg: (0..*segments).map(|_| TrackSegment::default()).collect(),
                    ..Default::default()
                })
                .collect(),
        );
        if waypoints > 0 {
            file.wpt = Waypoints::new([WaypointChunk {
                wpt: (0..waypoints).map(|_| Waypoint::default()).collect(),
                ..Default::default()
            }]);
        }
        file
    }

    fn add(fx: &mut Fixture, file: File) -> FileId {
        let id = file.id;
        fx.files.insert(id, Rc::new(file));
        fx.order.0.push(id);
        id
    }

    fn track_ids(fx: &Fixture, id: FileId) -> Vec<TrackId> {
        fx.files[&id].trk.iter().map(|trk| trk.id).collect()
    }

    fn segment_ids(fx: &Fixture, id: FileId, trk: usize) -> Vec<TrackSegmentId> {
        fx.files[&id].trk[trk].trkseg.iter().map(|s| s.id).collect()
    }

    fn wpt_ids(fx: &Fixture, id: FileId) -> Vec<WaypointId> {
        waypoint_ids(&fx.files[&id]).collect()
    }

    fn do_move(fx: &mut Fixture, what: Selection, to: MoveTarget) -> Result<(), CommandError> {
        Move { what, to }.apply(&mut fx.state())
    }

    fn tracks(file_id: FileId, ids: &[TrackId]) -> Selection {
        Selection::Track {
            file_id,
            trk_ids: ids.iter().copied().collect(),
        }
    }

    fn segments(file_id: FileId, trk_id: TrackId, ids: &[TrackSegmentId]) -> Selection {
        Selection::TrackSegment {
            file_id,
            trk_id,
            trkseg_ids: ids.iter().copied().collect(),
        }
    }

    fn waypoints(file_id: FileId, ids: &[WaypointId]) -> Selection {
        Selection::Waypoint {
            file_id,
            wpt_ids: ids.iter().copied().collect(),
        }
    }

    fn files(ids: &[FileId]) -> Selection {
        Selection::File {
            file_ids: ids.iter().copied().collect(),
        }
    }

    #[test]
    fn test_reorder_tracks_in_a_file() {
        let build = || {
            let mut fx = Fixture::default();
            let a = add(
                &mut fx,
                file("a", &[("0", 1), ("1", 1), ("2", 1), ("3", 1)], 0),
            );
            let t = track_ids(&fx, a);
            (fx, a, t)
        };
        let at = |a, index| MoveTarget::Tracks { file_id: a, index };

        // the position counts the tracks that stay
        let (mut fx, a, t) = build();
        do_move(&mut fx, tracks(a, &[t[0]]), at(a, 1)).unwrap();
        assert_eq!(track_ids(&fx, a), vec![t[1], t[0], t[2], t[3]]);
        assert_eq!(fx.selection, tracks(a, &[t[0]]));

        let (mut fx, a, t) = build();
        do_move(&mut fx, tracks(a, &[t[3]]), at(a, 0)).unwrap();
        assert_eq!(track_ids(&fx, a), vec![t[3], t[0], t[1], t[2]]);

        // several at once, as a block, in their order; past the end is the end
        let (mut fx, a, t) = build();
        do_move(&mut fx, tracks(a, &[t[1], t[0]]), at(a, 99)).unwrap();
        assert_eq!(track_ids(&fx, a), vec![t[2], t[3], t[0], t[1]]);
        assert_eq!(fx.selection, tracks(a, &[t[0], t[1]]));
    }

    #[test]
    fn test_move_tracks_to_another_file_or_to_new_files() {
        let mut fx = Fixture::default();
        let a = add(&mut fx, file("a", &[("t0", 1), ("t1", 1)], 0));
        let b = add(&mut fx, file("b", &[("b0", 1), ("b1", 1)], 0));
        let c = add(&mut fx, file("c", &[], 0));
        let t = track_ids(&fx, a);
        let b_tracks = track_ids(&fx, b);

        do_move(
            &mut fx,
            tracks(a, &[t[0]]),
            MoveTarget::Tracks {
                file_id: b,
                index: 1,
            },
        )
        .unwrap();
        assert_eq!(track_ids(&fx, a), vec![t[1]]);
        assert_eq!(track_ids(&fx, b), vec![b_tracks[0], t[0], b_tracks[1]]);
        assert_eq!(fx.selection, tracks(b, &[t[0]]));

        // as a new file, at a position of the list of files
        do_move(&mut fx, tracks(a, &[t[1]]), MoveTarget::Files { index: 1 }).unwrap();
        assert!(track_ids(&fx, a).is_empty());
        assert_eq!(fx.order.0.len(), 4);
        let new = fx.order.0[1];
        assert_eq!(fx.order.0[0], a);
        assert_eq!(fx.order.0[2..], [b, c]);
        assert_eq!(track_ids(&fx, new), vec![t[1]]);
        assert_eq!(fx.files[&new].info.name, "t1");
        assert_eq!(fx.selection, files(&[new]));
    }

    #[test]
    fn test_move_segments() {
        let build = || {
            let mut fx = Fixture::default();
            let a = add(&mut fx, file("a", &[("t0", 3), ("t1", 1)], 0));
            let t = track_ids(&fx, a);
            (fx, a, t)
        };

        // within a track
        let (mut fx, a, t) = build();
        let s = segment_ids(&fx, a, 0);
        do_move(
            &mut fx,
            segments(a, t[0], &[s[2]]),
            MoveTarget::Segments {
                file_id: a,
                trk_id: t[0],
                index: 0,
            },
        )
        .unwrap();
        assert_eq!(segment_ids(&fx, a, 0), vec![s[2], s[0], s[1]]);
        assert_eq!(fx.selection, segments(a, t[0], &[s[2]]));

        // to another track
        let (mut fx, a, t) = build();
        let s = segment_ids(&fx, a, 0);
        let other = segment_ids(&fx, a, 1);
        do_move(
            &mut fx,
            segments(a, t[0], &[s[0], s[1]]),
            MoveTarget::Segments {
                file_id: a,
                trk_id: t[1],
                index: 0,
            },
        )
        .unwrap();
        assert_eq!(segment_ids(&fx, a, 0), vec![s[2]]);
        assert_eq!(segment_ids(&fx, a, 1), vec![s[0], s[1], other[0]]);

        // as new tracks of a file
        let (mut fx, a, t) = build();
        let s = segment_ids(&fx, a, 0);
        do_move(
            &mut fx,
            segments(a, t[0], &[s[1]]),
            MoveTarget::Tracks {
                file_id: a,
                index: 1,
            },
        )
        .unwrap();
        assert_eq!(fx.files[&a].trk.len(), 3);
        assert_eq!(segment_ids(&fx, a, 1), vec![s[1]]);
        assert_eq!(segment_ids(&fx, a, 0), vec![s[0], s[2]]);
        assert_eq!(fx.files[&a].trk[0].id, t[0]);
        assert_eq!(fx.files[&a].trk[2].id, t[1]);

        // as new files
        let (mut fx, a, t) = build();
        let s = segment_ids(&fx, a, 0);
        do_move(
            &mut fx,
            segments(a, t[0], &[s[0], s[1]]),
            MoveTarget::Files { index: 0 },
        )
        .unwrap();
        assert_eq!(fx.order.0.len(), 3);
        assert_eq!(fx.order.0[2], a);
        assert_eq!(fx.files[&fx.order.0[0]].info.name, "t0");
        assert_eq!(segment_ids(&fx, a, 0), vec![s[2]]);
    }

    #[test]
    fn test_move_waypoints() {
        let build = || {
            let mut fx = Fixture::default();
            let a = add(&mut fx, file("a", &[], 4));
            let b = add(&mut fx, file("b", &[], 2));
            (fx, a, b)
        };
        let at = |file_id, index| MoveTarget::Waypoints { file_id, index };

        // within a file
        let (mut fx, a, _) = build();
        let w = wpt_ids(&fx, a);
        do_move(&mut fx, waypoints(a, &[w[3]]), at(a, 1)).unwrap();
        assert_eq!(wpt_ids(&fx, a), vec![w[0], w[3], w[1], w[2]]);
        assert_eq!(fx.selection, waypoints(a, &[w[3]]));

        // to the start of another file
        let (mut fx, a, b) = build();
        let w = wpt_ids(&fx, a);
        let before = wpt_ids(&fx, b);
        do_move(&mut fx, waypoints(a, &[w[0], w[1]]), at(b, 0)).unwrap();
        assert_eq!(wpt_ids(&fx, a), w[2..].to_vec());
        assert_eq!(wpt_ids(&fx, b), [&w[..2], &before[..]].concat());

        // all the waypoints of a file
        let (mut fx, a, b) = build();
        let w = wpt_ids(&fx, a);
        let before = wpt_ids(&fx, b);
        do_move(&mut fx, Selection::Waypoints { file_id: a }, at(b, 1)).unwrap();
        assert!(wpt_ids(&fx, a).is_empty());
        assert_eq!(
            wpt_ids(&fx, b),
            [&before[..1], &w[..], &before[1..]].concat()
        );
    }

    #[test]
    fn test_move_files() {
        let mut fx = Fixture::default();
        let a = add(&mut fx, file("a", &[], 0));
        let b = add(&mut fx, file("b", &[], 0));
        let c = add(&mut fx, file("c", &[], 0));
        do_move(&mut fx, files(&[c]), MoveTarget::Files { index: 0 }).unwrap();
        assert_eq!(fx.order.0, vec![c, a, b]);
        do_move(&mut fx, files(&[c, a]), MoveTarget::Files { index: 1 }).unwrap();
        assert_eq!(fx.order.0, vec![b, c, a]);
        assert_eq!(fx.selection, files(&[c, a]));
    }

    #[test]
    fn test_what_cannot_be_moved() {
        let mut fx = Fixture::default();
        let a = add(&mut fx, file("a", &[("t", 1)], 1));
        let t = track_ids(&fx, a);
        let s = segment_ids(&fx, a, 0);
        let w = wpt_ids(&fx, a);
        let before = fx.files[&a].clone();
        let selection = fx.selection.clone();

        let invalid = [
            // the wrong kind of list
            (
                files(&[a]),
                MoveTarget::Tracks {
                    file_id: a,
                    index: 0,
                },
            ),
            (
                tracks(a, &t),
                MoveTarget::Waypoints {
                    file_id: a,
                    index: 0,
                },
            ),
            (
                tracks(a, &t),
                MoveTarget::Segments {
                    file_id: a,
                    trk_id: t[0],
                    index: 0,
                },
            ),
            (
                segments(a, t[0], &s),
                MoveTarget::Waypoints {
                    file_id: a,
                    index: 0,
                },
            ),
            (
                waypoints(a, &w),
                MoveTarget::Tracks {
                    file_id: a,
                    index: 0,
                },
            ),
            (waypoints(a, &w), MoveTarget::Files { index: 0 }),
            (
                Selection::Waypoints { file_id: a },
                MoveTarget::Files { index: 0 },
            ),
            (Selection::Empty, MoveTarget::Files { index: 0 }),
            // elements that do not exist
            (
                tracks(a, &[TrackId::default()]),
                MoveTarget::Files { index: 0 },
            ),
            (
                waypoints(a, &[WaypointId::default()]),
                MoveTarget::Waypoints {
                    file_id: a,
                    index: 0,
                },
            ),
            (files(&[FileId::default()]), MoveTarget::Files { index: 0 }),
            // a place that does not exist
            (
                tracks(a, &t),
                MoveTarget::Tracks {
                    file_id: FileId::default(),
                    index: 0,
                },
            ),
            (
                segments(a, t[0], &s),
                MoveTarget::Segments {
                    file_id: a,
                    trk_id: TrackId::default(),
                    index: 0,
                },
            ),
            (
                waypoints(a, &w),
                MoveTarget::Waypoints {
                    file_id: FileId::default(),
                    index: 0,
                },
            ),
        ];
        for (what, to) in invalid {
            assert_eq!(
                do_move(&mut fx, what.clone(), to),
                Err(CommandError::NothingToDo),
                "{what:?} to {to:?}"
            );
            // nothing changed
            assert!(Rc::ptr_eq(&fx.files[&a], &before));
            assert_eq!(fx.order.0, vec![a]);
            assert_eq!(fx.selection, selection);
        }
    }
}