use tabled::{Tabled, Table};

#[derive(Tabled)]
struct Language {
    name: &'static str,
    designed_by: &'static str,
    invented_year: usize,
}

let languages = vec![
    Language{
        name: "C",
        designed_by: "Dennis Ritchie",
        invented_year: 1972
    },
    Language{
        name: "Rust",
        designed_by: "Graydon Hoare",
        invented_year: 2010
    },
    Language{
        name: "Go",
        designed_by: "Rob Pike",
        invented_year: 2009
    },
];

let table = Table::new(languages).to_string();

let expected = "+------+----------------+---------------+\n\
                | name | designed_by    | invented_year |\n\
                +------+----------------+---------------+\n\
                | C    | Dennis Ritchie | 1972          |\n\
                +------+----------------+---------------+\n\
                | Rust | Graydon Hoare  | 2010          |\n\
                +------+----------------+---------------+\n\
                | Go   | Rob Pike       | 2009          |\n\
                +------+----------------+---------------+";

assert_eq!(table, expected);

use tabled::TableIteratorExt;

let numbers = [1, 2, 3];
let table = numbers.table();
    
println!("{:#^10}", table);

use tabled::{Table, Style};

let mut table = Table::new(&data);
table.with(Style::psql());

let style = tabled::Style::modern().off_horizontal();

┌──────┬────────────────┬───────────────┐
│ name │ designed_by    │ invented_year │
│ C    │ Dennis Ritchie │ 1972          │
│ Rust │ Graydon Hoare  │ 2010          │
│ Go   │ Rob Pike       │ 2009          │
└──────┴────────────────┴───────────────┘

use tabled::style::{Style, HorizontalLine, VerticalLine};

let style = Style::modern()
    .off_horizontal()
    .off_vertical()
    .horizontals([HorizontalLine::new(1, Style::modern().get_horizontal())
        .main(Some('═'))
        .intersection(None)])
    .verticals([VerticalLine::new(1, Style::modern().get_vertical())]);

┌──────┬───────────────────────────────┐
│ name │ designed_by     invented_year │
├══════┼═══════════════════════════════┤
│ C    │ Dennis Ritchie  1972          │
│ Rust │ Graydon Hoare   2010          │
│ Go   │ Rob Pike        2009          │
└──────┴───────────────────────────────┘

use tabled::{object::Rows, Border, Modify, Style, TableIteratorExt};

let data = [["123", "456"], ["789", "000"]];

let table = data
    .table()
    .with(Style::ascii())
    .with(Modify::new(Rows::first()).with(Border::default().top('x')))
    .to_string();

let expected = "+xxxxx+xxxxx+\n\
                | 0   | 1   |\n\
                +-----+-----+\n\
                | 123 | 456 |\n\
                +-----+-----+\n\
                | 789 | 000 |\n\
                +-----+-----+";

assert_eq!(table, expected);

use tabled::{Table, BorderText};

let mut table = Table::new(["Hello World"]);
table.with(BorderText::new(0, "+-.table"));

assert_eq!(
    table.to_string(),
    "+-.table------+\n\
     | &str        |\n\
     +-------------+\n\
     | Hello World |\n\
     +-------------+"
);

use tabled::{
    object::Columns,
    style::{BorderChar, Offset, Style},
    Modify, Table,
};

fn main() {
    let table = Table::new([["Hello", "World", "!"]])
        .with(Style::markdown())
        .with(
            Modify::new(Columns::new(..))
                .with(BorderChar::horizontal(':', Offset::Begin(0)))
                .with(BorderChar::horizontal(':', Offset::End(0))),
        )
        .to_string();

    assert_eq!(
        table,
        "| 0     | 1     | 2 |\n\
         |:-----:|:-----:|:-:|\n\
         | Hello | World | ! |"
    );
}

use tabled::color::Color;

let color = Color::try_from(" ".magenta().to_string()).unwrap();

table.with(color)

use tabled::{Modify, style::{Symbol, BorderColored}, object::Columns};

// set a top border of each cell in second column to red '=' character.
let b = Symbol::ansi("═".red().to_string()).unwrap();

table.with(Modify::new(Columns::single(2)).with(BorderColored::default().top(c)))

use tabled::{TableIteratorExt, Modify, Alignment, object::Segment};

let mut table = data.table();
table
    .with(Modify::new(Segment::all()).with(Alignment::left()).with(Alignment::top()));

use tabled::{Table, Modify, format::Format, object::{Rows, Columns}};

let mut table = Table::new(&data);
table
    .with(Modify::new(Rows::first()).with(Format::new(|s| format!("Head {}", s))))
    .with(Modify::new(Columns::new(1..=2)).with(Format::new(|s| format!("<< {} >>", s))));

use tabled::{Table, Modify, object::{Rows, Columns}};

let mut table = Table::new(&data);
table
    .with(Modify::new(Columns::single(3)).with(|s: &str| format!("<< {} >>", s)))
    .with(Modify::new(Rows::first()).with(str::to_lowercase));

use tabled::{Table, Modify, Padding, object::Cell};

let mut table = Table::new(&data);
table.with(Modify::new(Cell(0, 3)).with(Padding::new(1, 1, 0, 2)));

// It's possible to set a fill char for padding.
let mut table = Table::new(&data)
table.with(Modify::new(Cell(0, 3)).with(Padding::new(1, 1, 0, 2).set_fill('>', '<', '^', 'V')));

use std::convert::TryFrom;
use owo_colors::OwoColorize;
use tabled::{
    color::Color, object::Segment, padding_color::PaddingColor, Modify, Padding, Table,
};

let mut table = Table::new(&data);

let on_red = Color::try_from(' '.on_red().to_string()).unwrap();
let padding = Modify::new(Segment::all())
    .with(Padding::new(1, 1, 0, 2))
    .with(PaddingColor::new(on_red.clone(), on_red.clone(), on_red.clone(), on_red));

table.with(padding);

use tabled::{Table, Margin};

let mut table = Table::new(&data);
table.with(Margin::new(3, 4, 1, 2).set_fill('>', '<', 'v', '^'));

use std::convert::TryFrom;
use owo_colors::OwoColorize;
use tabled::{color::Color, margin_color::MarginColor, Margin, Table};

let on_red = Color::try_from(' '.on_red().to_string()).unwrap();

let mut table = Table::new(&data);
table
    .with(Margin::new(3, 4, 1, 2))
    .with(MarginColor::new(on_red.clone(), on_red.clone(), on_red.clone(), on_red));

use tabled::{Style, TableIteratorExt, shadow::Shadow};

let data = vec![["A", "B", "C"]];
let table = data
    .table()
    .with(Style::modern())
    .with(Shadow::new(1))
    .to_string();

println!("{}", table);

use tabled::{TableIteratorExt, Modify, Width, object::Rows};

let mut table = data.table();

// Truncating content to 10 chars in case it's bigger than that
// in a first row.
table.with(Modify::new(Rows::first()).with(Width::truncate(10)));

// Truncating content to 7 chars and puts a suffix '...' after it
// in all rows except a first.
table.with(Modify::new(Rows::new(1..)).with(Width::truncate(10).suffix("...")));

use tabled::{TableIteratorExt, Width};

let mut table = data.table();

// Tries to set table width to 22, in case it's bigger than that.
table.with(Width::truncate(22));

use tabled::{TableIteratorExt, Modify, Width, object::Rows};

let mut table = data.table();

// Wrap content to 10 chars in case it's bigger than that
// in a first row.
table.with(Modify::new(Rows::first()).with(Width::wrap(10)));

// Use a strategy where we try to keep words not splited (where possible).
table.with(Modify::new(Rows::new(1..)).with(Width::wrap(10).keep_words()));

use tabled::{TableIteratorExt, Width};

let mut table = data.table();

// Tries to set table width to 22, in case it's bigger than that.
table.with(Width::wrap(22));

use tabled::{TableIteratorExt, Modify, Width, object::Rows};

let mut table = data.table();

// increase the space used by cells in all rows except the header to be at least 10
table.with(Modify::new(Rows::new(1..)).with(Width::increase(10)));

use tabled::{TableIteratorExt, Width};

let mut table = data.table();

// increase width of a table in case it was lower than 10.
table.with(Width::increase(10));

use tabled::{TableIteratorExt, Width};

let mut table = data.table();
table.with(Width::justify(10));

use tabled::{TableIteratorExt, Width, width::PriorityMax};

let mut table = data.table();
table.with(Width::truncate(10).priority::<PriorityMax>());

use tabled::width::{TableIteratorExt, Percent, Width};

let mut table = data.table();
table.with(Width::wrap(Percent(75)));

use tabled::{TableIteratorExt, Height, Modify, Rows};

let mut table = data.table();

// increase height of a table in case it was lower than 10.
table.with(Height::increase(10));

// increase height of cells in the last row on a table in case if some of them has it lower than 10.
table.with(Modify::new(Rows::last()).with(Height::increase(10)));

use tabled::{TableIteratorExt, Height, Modify, Rows};

let mut table = data.table();

// decrease height of a table to 10 in case it was bigger than that.
table.with(Height::limit(10));

// decrease height of cells in the last row on a table to 10 in case if some of them has it bigger than that.
table.with(Modify::new(Rows::last()).with(Height::limit(10)));

use tabled::Rotate;

table.with(Rotate::Left)

use tabled::{TableIteratorExt, Disable};

let mut table = data.table();
table
    .with(Disable::Row(..1))
    .with(Disable::Column(3..4));

use tabled::{Table, Extract};

let mut table = Table::new(&data);
table.with(Extract::segment(1..3, 1..));

use tabled::{Table, Extract, Style};

let mut table = Table::new(&data);
table
    .with(Extract::segment(1..3, 1..))
    .with(Style::modern());

use tabled::{Table, Panel};

let mut table = Table::new(&data);
table
    .with(Panel::header("Tabled Name"))
    .with(Panel::footer(format!("{} elements", data.len())))

use tabled::{Table, Panel};

let mut table = Table::new(&data);
table
    .with(Panel::vertical(2).text("A panel on 2nd row"))
    .with(Panel::horizontal(0).text("A panel on 1st column"));

use tabled::{merge::Merge, TableIteratorExt};

let data = [['A', 'B', 'B'], ['A', 'W', 'E'], ['Z', 'Z', 'Z']];

let mut table = data.table();
table
    .with(Merge::horizontal())
    .with(Merge::vertical());

println!("{}", table);

use tabled::Concat;

// let t1: Table = ...;
// let t2: Table = ...;

// vertical concat
t1.with(Concat::vertical(t2));

// horizontal concat
t1.with(Concat::horizontal(t2));

use tabled::{
    object::{Cell, Columns, Object, Rows},
    Border, Highlight, Style, TableIteratorExt,
};

let data = vec![
    ["A", "B", "C"],
    ["D", "E", "F"]
];

let mut table = data.table();
table
    .with(Style::modern())
    .with(Highlight::new(
        Rows::first().and(Columns::single(2).and(Cell(1, 1))),
        Border::filled('*'),
    ));

use tabled::{object::Cell, object::Segment, Alignment, Modify, Span, TableIteratorExt};

let data = vec![
    ["A", "B", "C"],
    ["D", "E", "F"],
];

let mut table = data.table();
table
    .with(Modify::new(Cell(0, 0)).with(Span::column(3)))
    .with(Modify::new(Cell(1, 0)).with(Span::column(2)))
    .with(Modify::new(Segment::all()).with(Alignment::center()));

println!("{}", table);

use tabled::{object::Cell, object::Segment, Alignment, Modify, Span, TableIteratorExt};

let data = vec![
    ["A", "B", "C"],
    ["D", "E", "F"],
];

let mut table = data.table();
table
    .with(Modify::new(Cell(0, 1)).with(Span::row(3)))
    .with(Modify::new(Segment::all()).with(Alignment::center()));

println!("{}", table);

use std::iter::FromIterator;
use tabled::{Table, settings::split::Split};

let mut table = Table::from_iter(['a'..='z']);
table.with(Split::column(12));
table.with(Split::row(2));

use tabled::{Table, settings::split::Split};

let mut table = Table::new(&data);

table.with(Split::column(2).concat());
table.with(Split::column(2).zip());

use std::iter::FromIterator;
use tabled::{
    settings::{split::Split, style::Style},
    Table,
};
let mut table = Table::from_iter(['a'..='z']);

table.with(Split::column(25)).with(Style::modern());
table.clone().with(Split::column(1).concat().retain());
table.clone().with(Split::column(1).concat()); // .clean() is not necessary as it is the default display property 

use tabled::Tabled;
#[derive(Tabled)]
struct SomeType {
    field1: SomeOtherType,
}

struct SomeOtherType;

use tabled::Tabled;

#[derive(Tabled)]
struct Person {
    #[tabled(rename = "Name")]
    first_name: &'static str,
    #[tabled(rename = "Surname")]
    last_name: &'static str,
}

use tabled::Tabled;

#[derive(Tabled)]
struct Person {
   id: u8,
   #[tabled(skip)]
   number: &'static str,
   name: &'static str,
}

use tabled::Tabled;

#[derive(Tabled)]
struct Person {
   id: u8,
   #[tabled(order = 0)]
   number: &'static str,
   #[tabled(order = 1)]
   name: &'static str,
}

use tabled::Tabled;

#[derive(Tabled)]
pub struct MyRecord {
    pub id: i64,
    #[tabled(display_with = "display_option")]
    pub valid: Option<bool>
}

fn display_option(o: &Option<bool>) -> String {
    match o {
        Some(s) => format!("is valid thing = {}", s),
        None => format!("is not valid"),
    }
}

use tabled::Tabled;

#[derive(Tabled)]
pub struct MyRecord {
    pub id: i64,
    #[tabled(display_with("Self::display_valid", args))]
    pub valid: Option<bool>
}

impl MyRecord {
    fn display_valid(&self) -> String {
        match self.valid {
            Some(s) => format!("is valid thing = {}", s),
            None => format!("is not valid"),
        }
    }
}

use tabled::Tabled;

#[derive(Tabled)]
#[tabled(rename_all = "CamelCase")]
struct Person {
    id: u8,
    number: &'static str,
    name: &'static str,
    #[tabled(rename_all = "snake_case")]
    middle_name: &'static str,
}

use tabled::Tabled;

#[derive(Tabled)]
struct Person {
    id: u8,
    name: &'static str,
    #[tabled(inline)]
    ed: Education,
}

#[derive(Tabled)]
struct Education {
    uni: &'static str,
    graduated: bool,
}

use tabled::Tabled;

#[derive(Tabled)]
enum Vehicle {
    #[tabled(inline("Auto::"))]
    Auto {
        model: &'static str,
        engine: &'static str,
    },
    #[tabled(inline)]
    Bikecycle(
        &'static str,
        #[tabled(inline)] Bike,
    ),
}

#[derive(Tabled)]
struct Bike {
    brand: &'static str,
    price: f32,
}

use tabled::{builder::Builder, Style};

let song = r#"
And the cat's in the cradle and the silver spoon
Little boy blue and the man on the moon
When you comin' home dad?
I don't know when, but we'll get together then son
You know we'll have a good time then
"#;

let mut builder = Builder::default();
let mut max_words = 0;
for line in song.lines() {
    if line.is_empty() {
        continue;
    }

    let words: Vec<_> = line.split_terminator(' ').collect();
    max_words = std::cmp::max(max_words, words.len());
    builder.add_record(words);
}

let columns = (0..max_words).map(|i| i.to_string()).collect::<Vec<_>>();
builder.set_columns(columns);

let mut table = builder.build();
table.with(Style::ascii_rounded());

println!("{}", table);

// previous example
// ...

let mut builder = builder.index();
builder.transpose();

use tabled::{builder::Builder, Style};

let mut builder = Builder::default();
builder
    .set_columns(["Index", "Language", "Status"])
    .add_record(["1", "English", "In progress"])
    .add_record(["2", "Deutsch", "Not ready"]);

let mut builder = builder.index();
builder.set_index(1).set_name(None);

let mut table = builder.build();
table.with(Style::rounded());

println!("{}", table);

use owo_colors::OwoColorize;
// ...
let mut builder = tabled::builder::Builder::default();
builder.add_record(vec!["green".green(), "red".red()])
let mut table = builder.build();
table.with(tabled::Style::rounded());

use tabled::{format::Format, object::Columns, Modify, Style, Table};

let mut table = Table::new(&data);
table
    .with(Style::psql())
    .with(Modify::new(Columns::single(0)).with(Format::new(|s| s.red().to_string())))
    .with(Modify::new(Columns::single(1)).with(Format::new(|s| s.blue().to_string())))
    .with(Modify::new(Columns::new(2..)).with(Format::new(|s| s.green().to_string())));

use tabled::{object::Segment, Alignment, ModifyObject, Style, Table, Tabled};

#[derive(Tabled)]
struct Developer(#[tabled(rename = "name")] &'static str);

#[derive(Tabled)]
enum Domain {
    Security,
    Embedded,
    Frontend,
    Unknown,
}

let data = vec![
    (Developer("Terri Kshlerin"), Domain::Embedded),
    (Developer("Catalina Dicki"), Domain::Security),
    (Developer("Jennie Schmeler"), Domain::Frontend),
    (Developer("Maxim Zhiburt"), Domain::Unknown),
];

let table = Table::new(data)
    .with(Style::psql())
    .with(Segment::all().modify().with(Alignment::center()))
    .to_string();

assert_eq!(
    table,
    concat!(
        "      name       | Security | Embedded | Frontend | Unknown \n",
        "-----------------+----------+---------+----------+---------\n",
        " Terri Kshlerin  |          |    +    |          |         \n",
        " Catalina Dicki  |    +     |         |          |         \n",
        " Jennie Schmeler |          |         |    +     |         \n",
        "  Maxim Zhiburt  |          |         |          |    +    ",
    )
);

use tabled::object::{Object, Segment, Cell, Rows, Columns};
Segment::all().not(Rows::first()); // select all cells except header.
Columns::first().and(Columns::last()); // select cells from first and last columns.
Rows::first().and(Columns::single(0)).not(Cell(0, 0)); // select the header and first column except the (0, 0) cell.

use tabled::{locator::ByColumnName, Alignment, Modify};

table.with(Modify::new(ByColumnName::new("name")).with(Alignment::center()));

row![table1, table2];

col![table1, table2];

row![table1; 3];

col![
    row![table_a, table_b], 
    table_c
]

use tabled::{display::ExpandedDisplay, Tabled};

#[derive(Tabled)]
struct Distribution {
    name: &'static str,
    is_active: bool,
    is_cool: bool,
}

let data = [
    Distribution {
        name: "Manjaro",
        is_cool: true,
        is_active: true,
    },
    Distribution {
        name: "Debian",
        is_cool: true,
        is_active: true,
    },
    Distribution {
        name: "Debian",
        is_cool: true,
        is_active: true,
    },
];

let table = ExpandedDisplay::new(&data);

println!("{}", table);

let languages = vec![
    Language {
        name: "C 💕",
        designed_by: "Dennis Ritchie",
        invented_year: 1972,
    },
    Language {
        name: "Rust 👍",
        designed_by: "Graydon Hoare",
        invented_year: 2010,
    },
    Language {
        name: "Go 🧋",
        designed_by: "Rob Pike",
        invented_year: 2009,
    },
];

+---------+----------------+---------------+
| name    | designed_by    | invented_year |
+---------+----------------+---------------+
| C 💕    | Dennis Ritchie | 1972          |
+---------+----------------+---------------+
| Rust 👍 | Graydon Hoare  | 2010          |
+---------+----------------+---------------+
| Go 🧋   | Rob Pike       | 2009          |
+---------+----------------+---------------+