/*
 * Copyright (C) 2022  Aravinth Manivannan <realaravinth@batsense.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
use std::collections::HashMap;
use std::rc::Rc;

use uuid::Uuid;

pub trait Purchasable {
    fn cost(&self) -> f64;
    fn name(&self) -> &str;
    fn paid_by(&self) -> Rc<dyn Actor>;
}

pub fn money_owned(splits: &[Split]) {
    for split in splits.iter() {}
}

#[derive(Clone)]
pub struct Split {
    purchase: Rc<dyn Purchasable>,
    split_strategy: SplitStrategy,
    parties: Vec<Rc<dyn Actor>>,
}


//#[derive(Clone)]
//pub struct Split {
//    shares: ShareHashMap,
//    paid_by: Rc<dyn Actor>,
//}

impl Split {
    pub fn new(purchase: Rc<dyn Purchasable>, split_strategy: SplitStrategy, parties: Vec<Rc<dyn Actor>>) -> Self {
        Self {
            split_strategy, parties, purchase
        }
    }

//    pub fn iter(&self) -> SplitIter {
//        let iter = self.shares.iter();
//        let paid_by = self.paid_by;
//        SplitIter { iter,  paid_by}
//    }
//
//    pub fn insert(&mut self, actor: Rc<dyn Actor>, amount: f64) {
//        let name = actor.name().to_owned();
//        self.shares.insert(name, (actor, amount));
//    }

    pub fn get(&mut self, actor: Rc<dyn Actor>) -> Option<f64> {
        unimplemented!();
//        if let Some((_actor, cost)) = self.shares.get(actor.name()) {
//            Some(*cost)
//        } else {
//            None
//        }
  }
}

//pub struct SplitIter<'a> {
//    iter: std::collections::hash_map::Iter<'a, String, (Rc<dyn Actor>, f64)>,
//    paid_by: Rc<dyn Actor>,
//}
//
//impl<'a> Iterator for SplitIter<'a> {
//    type Item = (Rc<dyn Actor>, f64);
//
//    fn next(&mut self) -> Option<Self::Item> {
//        if let Some((_, (actor, cost))) = self.iter.next() {
//            Some((actor.clone(), *cost))
//        } else {
//            None
//        }
//    }
//}

impl Split {
    pub fn validate(&self) -> bool {
        self.split_strategy.validate(&self)
    }
}


// key is a string for getting Eq and PartialEq w object safety
pub type ShareHashMap  = HashMap<String, (Rc<dyn Actor>, f64)>;


/*
 * SPLITTING STRATEGIES:
 *  Unequal: Each actor's split is specified in specific amounts
 *  Shares: Each actor's split is specified in specific percentage
 *  Equal: Each actor's split is computed by splitting total expense among all participating actors
 */
#[derive(Clone)]
pub enum SplitStrategy {
    Unequal(ShareHashMap),
    Shares(ShareHashMap),
    Equal,
}

impl SplitStrategy {
    pub fn validate(&self, split: &Split) -> bool {
        match self {
            SplitStrategy::Unequal(shares) => {
                let mut total = 0.00;
                for (_actor_str, (_actor_obj, share)) in shares.iter() {
                    total += share;
                }

                let cost = split.purchase.cost();
                println!("Unequal sharing: expected {cost} got {total}");
                total == cost
            }
            SplitStrategy::Shares(shares) => {
                let mut total = 0.00;
                let cost = split.purchase.cost();
                let mut total_shares = 0.00;
                for (_actor_str, (_actor_obj, share)) in shares.iter() {
                    total_shares += share;
                    total += cost * share;
                }

                println!("Unequal sharing: expected shares 1 got {total_shares}");
                println!("Unequal sharing: expected {cost} got {total}");
                total_shares == 1.00 && total == cost
            }
            SplitStrategy::Equal => true,
        }
    }

    pub fn money_owed(&self, split: &Split) -> ShareHashMap {
        match self {
            SplitStrategy::Unequal(shares) => {
                let mut s  = shares.clone();
                let payer = split.purchase.paid_by();
                    if let Some((_,money)) = s.get_mut(payer.name()) {
                    *money = 0.0;
                    }
                    s

            }
            SplitStrategy::Equal => {
                let mut shares = ShareHashMap::default();
                let cost = split.purchase.cost();
                for actor in split.parties.iter() {
                    if *actor == split.purchase.paid_by() {
                        shares.insert(actor.name().to_owned(), (actor.clone(), 0.00));
                    } else {
                        shares.insert(actor.name().to_owned(), (actor.clone(), cost / split.parties.len() as f64));
                    }
                }

                shares
            }
            SplitStrategy::Shares(c) => {
                let mut shares = ShareHashMap::default();
                let cost = split.purchase.cost();
                for (actor_name,(actor, share)) in c.iter() {
                    //if actor.name() == split.purchase.paid_by().name() {
                    if *actor == split.purchase.paid_by() {
                        shares.insert(actor_name.clone(), (actor.clone(), 0.00));
                    } else {
                        shares.insert(actor_name.clone(), (actor.clone(), cost * share));
                    }
                }
                shares
            }
        }
    }
}

pub trait Actor {
    fn spends(&mut self, i: Split);
    fn owes(&mut self, i: Split);
    // name must be unique in a namespace
    fn name(&self) -> &str;
    fn id(&self) -> &Uuid;
}

impl PartialEq for dyn Actor {
    fn eq(&self, other: &Self) -> bool {
        self.id() == other.id()
    }
}

pub struct Person {
    name: String,
    spent: Vec<Split>,
    owes: Vec<Split>,
    id: Uuid,
}

impl Person {
    pub fn new(name: String, id: Uuid) -> Self {
        let owes = Vec::default();
        let spent = Vec::default();

        Self { name, spent, owes, id}
    }
}

impl Actor for Person {
    fn spends(&mut self, split: Split) {
        if split.purchase.paid_by().name() == self.name() {
            self.spent.push(split);
        } else {
            unimplemented!("Raise error: Actor didn't pay for purchase")
        }
    }
    fn owes(&mut self, split: Split) {
        if split.purchase.paid_by().name() == self.name() {
            unimplemented!("Raise error: Actor didn't paid for purchase; can't own money")
        } else {
            self.owes.push(split);
        }
    }
    fn name(&self) -> &str {
        &self.name
    }
    fn id(&self) -> &Uuid {
        &self.id
    }

}

pub struct Item {
    cost: f64,
    name: String,
    payer: Rc<dyn Actor>,
}

impl Item {
    pub fn new(name: String, cost: f64, payer: Rc<dyn Actor>) -> Self {
        Self { cost, name, payer }
    }
}

impl Purchasable for Item {
    fn cost(&self) -> f64 {
        self.cost
    }
    fn name(&self) -> &str {
        &self.name
    }

    fn paid_by(&self) -> Rc<dyn Actor> {
        self.payer.clone()
    }
}

//impl Actor for Person {
//    fn spends<P: Purchasable>(&self, i: &I);
//    fn owes<T: Actor>(&self, amount: usize);
//}

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

    #[test]
    fn split_works() {
        let person1: Rc<dyn Actor> = Rc::new(Person::new("person1".into(), Uuid::new_v4()));
        let person2: Rc<dyn Actor> = Rc::new(Person::new("person2".into(), Uuid::new_v4()));
        let person3: Rc<dyn Actor> = Rc::new(Person::new("person3".into(), Uuid::new_v4()));
        let person4: Rc<dyn Actor> = Rc::new(Person::new("person4".into(), Uuid::new_v4()));

        let item = Item::new("test item".into(), 240.00, person1.clone());
        let actors = vec![
            person1.clone(),
            person2.clone(),
            person3.clone(),
            person4.clone(),
        ];
        

        // equal split
        let strategy = SplitStrategy::Equal;

        let mut split = Split::new(Rc::new(item), strategy, actors);
        assert!(split.split_strategy.validate(&split));
        let dues = split.split_strategy.money_owed(&split);
        for (_actor_name,(actor, due)) in dues.iter() {
            if split.purchase.paid_by().name() == actor.name() {
                assert_eq!(*due, 0.00);
            } else {
                assert_eq!(*due, split.purchase.cost() / split.parties.len() as f64);
            }
        }

        // share split
        let mut shares = ShareHashMap::default();
        shares.insert(person1.name().to_owned(), (person1.clone(), 0.3));
        shares.insert(person2.name().to_owned(), (person2.clone(), 0.4));
        shares.insert(person3.name().to_owned(), (person3.clone(), 0.2));
        shares.insert(person4.name().to_owned(), (person4.clone(), 0.1));
        let strategy = SplitStrategy::Shares(shares.clone());

        split.split_strategy = strategy;
        assert!(split.split_strategy.validate(&split));

        let dues = split.split_strategy.money_owed(&split);
        for (actor_name, (actor, due)) in dues.iter() {
            println!("Testing for actor: {actor_name} with due: {due}");
            if split.purchase.paid_by().name() == actor.name() {
                assert_eq!(*due, 0.00);
            } else {
                let (_, share) = shares.get(actor_name).unwrap();
                assert_eq!(*due, split.purchase.cost() * *share);
            }
        }

        // Unequal split
        let mut shares = ShareHashMap::default();
        shares.insert(person1.name().to_owned(), (person1.clone(), 0.3 * split.purchase.cost()));
        shares.insert(person2.name().to_owned(), (person2.clone(), 0.4 * split.purchase.cost()));
        shares.insert(person3.name().to_owned(), (person3.clone(), 0.2 * split.purchase.cost()));
        shares.insert(person4.name().to_owned(), (person4.clone(), 0.1 * split.purchase.cost()));
        let strategy = SplitStrategy::Unequal(shares);
        split.split_strategy = strategy;
        assert!(split.split_strategy.validate(&split));


    }

}