use db::LayoutDB;
use city::{City, House, SIZE};
use itertools::Itertools;

mod city;
mod db;
mod combine;

fn main() {
    let mut db = LayoutDB::from_file("layouts.sqlite").expect("Failed to load the DB");
    eprintln!("Loaded the DB, {} stored layouts", db.layouts().len());

    let city = City::read_from_file("01.in");
    eprintln!("Loaded the city file, {} houses", city.get_house_count());

    let layouts = db.layouts();
    let sorted: Vec<_> = layouts.iter().sorted_by(|x, y| city::get_price(&city, x.houses()).cmp(&city::get_price(&city, y.houses()))).collect();

    const TOP_LAYOUT_COUNT: usize = 100;

    let chosen_layouts: Vec<_> = sorted.iter().take(TOP_LAYOUT_COUNT).map(|l| l.houses().clone()).collect();

    //eprintln!("Starting to combine {} top houses DB; vertical cuts", TOP_LAYOUT_COUNT);
    //combine::try_combine(&city, &chosen_layouts, &chosen_layouts, false);

    eprintln!("Transposing...");
    let transposed_city = transpose_city(&city);
    let transposed_chosen_layouts: Vec<_> = chosen_layouts.iter().map(|x| transpose_layout(x)).collect();
    eprintln!("Starting to combine {} top houses DB; horizontal cuts", TOP_LAYOUT_COUNT);
    combine::try_combine(&transposed_city, &transposed_chosen_layouts, &transposed_chosen_layouts, true);
}

fn transpose_city(city: &City) -> City {
    let mut transposed_prices = vec![0u16; SIZE * SIZE];
    for y in 0..SIZE {
        for x in 0..SIZE {
            // Sorry, cache! Not worth optimizing with blocks,
            // this is not going to be ran often.
            transposed_prices[y * SIZE + x] = city.get_price_xy(y, x);
        }
    }

    City::new(transposed_prices)
}

fn transpose_layout(houses: &Vec<House>) -> Vec<House> {
    let mut transposed = Vec::new();
    for house in houses {
        transposed.push(House::new(house.y, house.x));
    }

    transposed
}