//
// When inserting a new Order into the royalties tree, we must make sure the existing
// royalties don't get shared with that new node. To do this, we must "shave" down
// the tree, pushing royalties from the root down to all nodes to the left of the
// new node.
//
// Case to think about:
//   Selling 140000 USD to buy 2 BTC. Weight is ===140k USD
//   Selling  50000 GBP to buy 1 BTC. Weight is === 50k GBP 
//
#![allow(unsafe_code)]
#![allow(unused_variables)]
#![allow(dead_code)]
use std::env;
use std::collections::HashMap;
use std::cmp::Ordering;
use std::rc::Rc;
use std::cell::RefCell;
use rand::prelude::*;
use rand::rngs::StdRng;
use finum::FiNum;

#[derive(Debug, Clone)]
struct Trader {
    name: String,
    id: usize,    
    balances: HashMap<usize,FiNum>, // Maps Currency to Amount
    }

impl Trader {
    fn new(name:&str,id:usize) -> Self {
        Trader {
            name: String::from(name),
            id: id,
            balances: HashMap::new()
            }
        }
    fn add_balance(&mut self, cur:usize, delta:FiNum) {
        self.balances.entry(cur).and_modify(|ent| *ent+=delta ).or_insert_with(|| delta);
        }
    fn sub_balance(&mut self, cur:usize, delta:FiNum) {
        self.balances.entry(cur).and_modify(|ent| *ent-=delta );
        }
    fn get_balance(&self, cur:usize) -> FiNum {
        *self.balances.get(&cur).map(|bal| bal).unwrap_or(&FiNum::new(0u64))
        }
    }

#[derive(Debug, Clone)]
struct Order {
    sell_qty: FiNum,
    sell_remain: FiNum,
    buy_qty: FiNum,
    owner: usize,
    rt_loc: usize,      // Location in the Royalty Tree
    }

struct RoyaltyTree {
    tree: Vec<Royalty>,
    next_entry: usize,
    }

struct Royalty {
    weight: FiNum,      // Here and below
    lazy: FiNum,        // To be distributed to here and to below based on weights
    acc: FiNum,         // Accumulated here
    }

impl Royalty {
    fn new() -> Self {
        Royalty { weight:FiNum::zero(), lazy:FiNum::zero(), acc:FiNum::zero() }
        }
    }

impl RoyaltyTree {
    fn new() -> Self {
        RoyaltyTree { tree:Vec::new(), next_entry:0 }
        }
    fn weight_here_below(&self, index:usize) -> FiNum {
        self.tree[index].weight
        }
    fn weight_below(&self, index: usize) -> FiNum {
        if index&1==0 {
            FiNum::zero()
        } else {
            let w0=self.weight_here_below(wt_left (index).unwrap());
            let w1=self.weight_here_below(wt_right(index).unwrap());
            w0+w1
            }
        }
    fn weight_here(&self, index:usize) -> FiNum {
        if index&1==0 {
            self.weight_here_below(index)
        } else {
            let w0=self.weight_here_below(index);
            let w1=self.weight_below(index);
            println!("Weight_here at {}, weight_here_below {}, weight_below {}",index,w0,w1);
            w0-w1
            }
        }
    fn expand_to(&mut self, index: usize) -> &mut Self {
        println!("Expand_to {} ",index);
        for _ in self.tree.len()..=index { println!("    Push!"); self.tree.push(Royalty::new()) }
        self
        }
    fn capture0(&mut self, index: usize) -> &mut Self {
        if index&1==0 {
            let lazy=self.tree[index].lazy;
            self.tree[index].acc+=lazy;
            self.tree[index].lazy=FiNum::zero();
        } else {
            let lazy=self.tree[index].lazy;
            let d1=lazy*self.weight_here(index)/self.weight_here_below(index);
            let d02=lazy-d1;
            let index_left =wt_left (index).unwrap();
            let index_right=wt_right(index).unwrap();
            let d0=d02*self.weight_here_below(index_left)/self.weight_below(index);
            let d2=d02-d0;
            assert!(lazy==d0+d1+d2,"Distributing amounts that don't add up.");
            self.tree[index_left ].lazy+=d0;
            self.tree[index_right].lazy+=d2;
            self.tree[index].acc+=d1;
            self.tree[index].lazy=FiNum::zero();
            }
        self
        }
    fn get_royalty(&mut self, index: usize) -> FiNum {
        let mut f=self.forefather();
        while f!=index {
            self.capture0(f);
            f=if f>index { wt_left(f).unwrap() } else { wt_right(f).unwrap() }
            }
        self.capture0(f);
        self.tree[index].acc
        }
    fn add_royalty(&mut self, amount: FiNum) {
        let ff=self.forefather();
        self.tree[ff].lazy+=amount;
        println!("Add royalty amount {}, storing at node {}, lazy amount there is now {}",amount,ff,self.tree[ff].lazy);
        }
    fn add_weight(&mut self, index: usize, weight: FiNum) {
        println!("Add_weight at {}",index);
        if self.tree.len()>0 {
            let mut ff0=self.forefather();
            self.expand_to(wt_forefather(index)*2);
            let ff=self.forefather();
            while ff0!=ff {
                let w=self.tree[ff0].weight;
                ff0=wt_parent(ff0);
                self.tree[ff0].weight=w;
                }
            }
        let ff=self.forefather();
        self.get_royalty(index); // Just for the side effect of capturing everything to this point
        let mut index=index;
        println!("Ascending from {} to {}",index,ff);
        while index!=ff {
            self.tree[index].weight+=weight;
            index=wt_parent(index);
            }
        self.tree[index].weight+=weight;
        }
    fn forefather(&self) -> usize {
        wt_forefather(self.tree.len()-1)
        }
    fn dump(&mut self) {
        for index in 0..self.tree.len() {
            let roy=self.get_royalty(index);
            println!("Index {} Weight {} Lazy {} Acc {} Royalty {}",index,self.tree[index].weight,self.tree[index].lazy,self.tree[index].acc,roy);
            }
        }
    }


trait Dumpable {
    fn dump(&self);
    }

impl Dumpable for usize {
    fn dump(&self) {
        println!("Dump Integer: {}",self);
        }
    }


impl Dumpable for Rc<RefCell<Order>> {
    fn dump(&self) {
        }
    }


impl Dumpable for Order {
    fn dump(&self) {
        println!("Giving {}/{} to get {}",self.sell_remain,self.sell_qty,self.buy_qty);
        }
    }



struct Market {
    asset_name2num: HashMap<String,usize>,
    asset_num2name: HashMap<usize,String>,
    asset_count:usize,
    money_supply: HashMap<usize,FiNum>,
    traders: Vec<Trader>,
    trader_name2num: HashMap<String,usize>,
    orders: HashMap<(usize,usize),PQueue<Rc<RefCell<Order>>>>,
    royalties: HashMap<usize,RoyaltyTree>, // Active orders that are accepting asset X. They receive royalties when someone makes an order to sell X
    }

impl Market {
    fn new() -> Self {
        let mut rval=Market {
            asset_name2num: HashMap::new(),
            asset_num2name: HashMap::new(),
            asset_count:0,
            money_supply: HashMap::new(),
            orders: HashMap::new(),
            royalties: HashMap::new(),
            traders: Vec::new(),
            trader_name2num: HashMap::new(),
            };
        rval.register_trader("*NONE*");
        rval
        }
    fn distribute_royalty(&self, amount:FiNum) {
        
        }
    fn sanity_check(&self) {
        println!("Sanity Checking Market...");
        for (cur,amt) in self.money_supply.iter() {
            println!("Money Supply {}: {}",self.number_to_name(*cur),*amt);
            let mut acc_orders=FiNum::new(0);
            for (ac,pq) in &self.orders { if ac.0==*cur {
                for off in &*pq.v { acc_orders+=off.borrow().sell_remain; }
                } }
            let mut acc_traders=FiNum::new(0);
            for t in &self.traders { acc_traders+=t.get_balance(*cur); }
            let acc=acc_orders+acc_traders;
            println!("    {}: Orders {} Traders {} Total {} Should Be {}",self.number_to_name(*cur),acc_orders,acc_traders,acc,*amt);
            }
        }
    fn register_trader(&mut self, name:&str) -> usize { // Add error checking for inserting a trader twice
        let rval=self.traders.len();
        self.trader_name2num.insert(String::from(name),self.traders.len());
        self.traders.push(Trader::new(name,rval));
        rval
        }
    // These are the only ways to get money into or out of the market.
    fn add_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) {
        self.traders[who as usize].add_balance(cur,delta);
        *self.money_supply.get_mut(&cur).unwrap()+=delta;
        }
    fn sub_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) {
        self.traders[who as usize].sub_balance(cur,delta);
        *self.money_supply.get_mut(&cur).unwrap()-=delta;
        }
    fn register_asset(&mut self, name:&str) -> usize {
        self.asset_count+=1;
        self.asset_name2num.insert(String::from(name),self.asset_count);
        self.asset_num2name.insert(self.asset_count,String::from(name));
        self.money_supply.insert(self.asset_count,FiNum::new(0));
        self.asset_count
        }
    fn name_to_number(&self, name:&str) -> usize {
        *self.asset_name2num.get(name).unwrap()
        }
    fn number_to_name(&self, num:usize) -> &str {
        &*self.asset_num2name.get(&num).unwrap()
        }
    fn dump(&self) {
        println!("Dumping Market:");
        for t in &self.traders {
            println!("    Trader {}: {}",t.id,t.name);
            for (cur,bal) in t.balances.iter() {
                println!("        {}: {}",self.number_to_name(*cur),*bal)
                }
            }
        for (ap,pq) in &self.orders {
            println!("Orders selling {} to buy {}:",self.number_to_name(ap.0),self.number_to_name(ap.1));
            let mut sorted=pq.v.clone();
            sorted.sort_by(|a,b| { let a=a.borrow(); let b=b.borrow(); (a.sell_qty/a.buy_qty).cmp(&(b.sell_qty/b.buy_qty)) });
            for off in sorted.iter() {
                let off=off.borrow();
                println!("    {} @ {} ({})",
                         off.sell_remain,              // off.buy_qty*off.sell_remain/off.sell_qty,
                         off.buy_qty/off.sell_qty,
                         self.traders[off.owner as usize].name);
                }
            pq.dump();
            }
        }
    fn make_order(&mut self, owner:usize, sell_type:usize, buy_type:usize, sell_qty_initial:FiNum, buy_qty_initial:FiNum) -> bool // Dollars, Bitcoin, 64000, 1
        {
        let initial_balance=self.traders[owner as usize].get_balance(sell_type);
        if initial_balance<sell_qty_initial { return false; }
        let mut buy_qty=buy_qty_initial;
        let ap=(buy_type,sell_type);
        while buy_qty>FiNum::new(0) && self.orders.contains_key(&ap) && self.orders.get(&ap).unwrap().v.len()>0 {
            let mut elt=(*(self.orders.get(&ap).unwrap().v[0].borrow())).clone();
            if sell_qty_initial/buy_qty_initial>=elt.buy_qty/elt.sell_qty { // Transact at ask_rate
                let qty=std::cmp::min(elt.sell_remain,buy_qty);
                elt.sell_remain-=qty;
                buy_qty-=qty;
                let pay_qty=qty*elt.buy_qty/elt.sell_qty; // 1.8499*194623/2.9744
                self.traders[owner     as usize].sub_balance(sell_type,pay_qty);
                self.traders[owner     as usize].add_balance(buy_type ,qty); 
                self.traders[elt.owner as usize].add_balance(sell_type,pay_qty);
                if elt.sell_remain==0.into() { self.orders.get_mut(&ap).unwrap().pop(); }
                else { self.orders.get(&ap).unwrap().v[0].borrow_mut().sell_remain-=qty; }
            } else { break; }
            }
        if buy_qty>0.into() {
            let ap=(sell_type,buy_type);
            if let None=self.orders.get_mut(&ap) { self.orders.insert(ap,PQueue::new()); }
            let bids=self.orders.get_mut(&ap).unwrap();
            let sell_qty_remain=sell_qty_initial*buy_qty/buy_qty_initial;
            if sell_qty_remain>0.into() {
//                self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()).insert(sell_qty_remain);
//                let rt_loc=self.royalties.get(&sell_type).unwrap().tree.len();
                let neworder=Rc::new(RefCell::new(
                    Order { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty, rt_loc: 0 } ));
                bids.insert(neworder);
                self.traders[owner as usize].sub_balance(sell_type,sell_qty_remain);
                }
            }
        true
        }
    }

impl PartialOrd for Order {  
    fn partial_cmp(&self, other:&Self) -> Option<Ordering> {
        let ord0=self .sell_qty/self .buy_qty;
        let ord1=other.sell_qty/other.buy_qty;
        if      ord0<ord1 { Some(Ordering::Less) }
        else if ord0>ord1 { Some(Ordering::Greater) }
        else              { Some(Ordering::Equal) }
        }
    }

impl PartialEq for Order {
    fn eq(&self, other:&Self) -> bool {
        let ord0=self .sell_qty/self .buy_qty;
        let ord1=other.sell_qty/other.buy_qty;
        ord0==ord1
        }
    }


struct PQueue<T: Dumpable> {
  v: Vec<T>,
  }

impl<T: Dumpable + std::cmp::PartialOrd + std::fmt::Debug> PQueue<T> {
    fn new()->Self {
        PQueue {
            v: Vec::new()
            }
        }
    fn peek(&self) -> &T {
        &self.v[0]
        }
    fn bubble_up(&mut self, pos: usize) {
        if pos>0 {
            let parent=(pos-1)/2;
            if self.v[parent]<self.v[pos] {
                self.v.swap(parent,pos);
                self.bubble_up(parent);
                }
            }
        }
    fn trickle_down(&mut self, pos: usize) {
        let mut pivot=pos;
        let child0=pos*2+1;
        let child1=pos*2+2;
        if child0<self.v.len() {
            if self.v[pos]<self.v[child0] { pivot=child0; }
            if child1<self.v.len() {
                if self.v[pivot]<self.v[child1] { pivot=child1; }
                }
            if pivot!=pos {
                self.v.swap(pivot,pos);
                self.trickle_down(pivot);
                }
            }
        }
    fn insert(&mut self, item: T) {
        self.v.push(item);
        self.bubble_up(self.v.len()-1);
        }
    fn pop(&mut self) -> Option<T> {
        if self.v.len()==0 { None }
        else {
            let end=self.v.len()-1;
            self.v.swap(0,end);
            let rval=self.v.pop();
            self.trickle_down(0);
            rval
            }
        }
    fn dump(&self) {
        for index in 0..self.v.len() {
            self.v[index].dump();
            }
        }
    }

impl Market {
    fn exercise(&mut self) {
        let mut rng: StdRng=StdRng::seed_from_u64(13u64);
        let teppy=self.register_trader("Teppy");  
        let luni =self.register_trader("Luni");
        let usd  =self.register_asset("USD");
        let btc  =self.register_asset("BTC");
        self.add_trader_balance(teppy,btc,100000.into());
        self.add_trader_balance(luni ,usd,650000000.into());
        let mut count=0;
        let mut tries=0;
        for _i in 1..=1000000 {
            let seller=if rng.gen_bool(0.5) { teppy } else { luni };
            let (buy_type,sell_type,buy_qty,sell_qty):(usize,usize,FiNum,FiNum);
            if rng.gen_bool(0.5) {
                sell_type=btc;
                buy_type=usd;
                sell_qty=rng.gen_range(1..=5).into();
                buy_qty=sell_qty*rng.gen_range(60..=70).into();
            } else {
                sell_type=usd;
                buy_type=btc;
                buy_qty=rng.gen_range(1..=5).into();
                sell_qty=buy_qty*rng.gen_range(60..=70).into();
                }
            let mut _success=false;
            if self.make_order(seller,sell_type,buy_type,sell_qty,buy_qty) { count+=1; _success=true; };
            if count>=1000000 { break; }
            tries+=1;
            }
        println!("Tries: {} Trades: {}",tries,count);
        self.sanity_check();
        }
    }

fn wt_level(index:usize) -> usize {
    (index^(index+1)).trailing_ones() as usize-1
    }

fn wt_leaf(index:usize) -> bool {
    index&1==0
    }

fn wt_left(index:usize) -> Option<usize> {
    let level=wt_level(index);
    if level>0 { Some(index-(1<<(wt_level(index)-1))) } else { None }
    }

fn wt_right_edge(index: usize, edge: usize) -> Option<usize> { // Less than edge
    if index&1==0 { None }
    else {
        let mut r=wt_right(index).unwrap();
        if r<edge { Some(r) }
        else {
            while r&1==1 {
                if r<edge { return Some(r); }
                else { r=wt_left(r).unwrap(); }
                }
            if r<edge { Some(r) } else { None }
            }
        }
    }

fn wt_right(index:usize) -> Option<usize> {
    let level=wt_level(index);
    if level>0 { Some(index+(1<<(wt_level(index)-1))) } else { None }
    }

fn wt_parent(index:usize) -> usize {
    let lev=wt_level(index);
    let first_in_row=index%(1<<lev);
    let skip=2<<lev;
    let nth_in_row=(index-first_in_row)/skip;
    let first_in_parent_row=(2<<lev)-1;
    let skip_in_parent_row=4<<lev;
    let nth_in_parent_row=nth_in_row>>1;
    first_in_parent_row+nth_in_parent_row*skip_in_parent_row
    }

fn wt_forefather(max_index:usize) -> usize {
    let mut rval=max_index;
    rval=rval|(rval>>1);
    rval=rval|(rval>>2);
    rval=rval|(rval>>4);
    rval=rval|(rval>>8);
    rval=rval|(rval>>16);
    rval=rval|(rval>>32);
    if rval>max_index { wt_left(rval).unwrap() } else { rval }
    }

fn tree_stuff() {
    for i in (0..=60).step_by(1) {
        println!("Index {} Forefather {} Parent {}",i,wt_forefather(i),wt_parent(i));
        }
    }

fn royalty_stuff() {
    let mut rt=RoyaltyTree::new();
    for index in 0..20 {
        rt.add_weight(index,FiNum::new_i32(10));
        rt.add_royalty(FiNum::new_i32(24))
        }
    for index in 0..rt.tree.len() {
        println!("Index: {} Weight_here {} Weight_below {} Weight_here_below {}",index,rt.weight_here(index),rt.weight_below(index),rt.weight_here_below(index));
        }
    }


fn main() {
    let args: Vec<String> = env::args().collect();
    let mode=if args.len()<=1 { "--exercise" } else { args[1].as_str() };
    let mut m=Market::new(); // USD type is 1, EUR type is 2, BTC type is 10, ETH type is 11, zKN6FBdD SOL type is 12
    match mode {
        "--exercise" => m.exercise(),
        "--treestuff" => tree_stuff(),
        "--royaltystuff" => royalty_stuff(),
        _ => println!("Unknown mode: {}",mode),
        }
    }