use super::*;

/// Draw border around item shrunk by 1 on each side.
///
/// ```
/// /// TODO
/// ```
pub const fn border (on: bool, style: impl BorderStyle, draw: impl Draw<Tui>) -> impl Draw<Tui> {
    let content = wh_pad(1, 1, draw);
    let outline = when(on, thunk(move|to: &mut Tui|{
        let XYWH(x, y, w, h) = to.1;
        if w > 0 && h > 0 {
            to.blit(&style.border_nw(), x, y, style.style());
            to.blit(&style.border_ne(), x + w - 1, y, style.style());
            to.blit(&style.border_sw(), x, y + h - 1, style.style());
            to.blit(&style.border_se(), x + w - 1, y + h - 1, style.style());
            for x in x+1..x+w-1 {
                to.blit(&style.border_n(), x, y, style.style());
                to.blit(&style.border_s(), x, y + h - 1, style.style());
            }
            for y in y+1..y+h-1 {
                to.blit(&style.border_w(), x, y, style.style());
                to.blit(&style.border_e(), x + w - 1, y, style.style());
            }
        }
        Ok(Some(XYWH(x, y, w, h)))
    }));
    above(outline, content)
}

macro_rules! border {
    ($($T:ident {
        $nw:literal $n:literal $ne:literal $w:literal $e:literal $sw:literal $s:literal $se:literal
        $($x:tt)*
    }),+) => {$(
        impl BorderStyle for $T {
            const NW: &'static str = $nw;
            const N:  &'static str = $n;
            const NE: &'static str = $ne;
            const W:  &'static str = $w;
            const E:  &'static str = $e;
            const SW: &'static str = $sw;
            const S:  &'static str = $s;
            const SE: &'static str = $se;
            $($x)*
            fn enabled (&self) -> bool { self.0 }
        }
        #[derive(Copy, Clone)] pub struct $T(pub bool, pub Style);
        //impl Layout<Tui> for $T {}
        impl Draw<Tui> for $T {
            fn draw (self, to: &mut Tui) -> Perhaps<XYWH<u16>> {
                when(self.enabled(), thunk(|to: &mut Tui|BorderStyle::draw(self, to))).draw(to)
            }
        }
    )+}
}

border! {
    Square {
        "┌" "─" "┐"
        "│"     "│"
        "└" "─" "┘" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    SquareBold {
        "┏" "━" "┓"
        "┃"     "┃"
        "┗" "━" "┛" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    TabLike {
        "╭" "─" "╮"
        "│"     "│"
        "│" " " "│" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Lozenge {
        "╭" "─" "╮"
        "│"     "│"
        "╰" "─" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Brace {
        "╭" "" "╮"
        "│"    "│"
        "╰" "" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    LozengeDotted {
        "╭" "┅" "╮"
        "┇"     "┇"
        "╰" "┅" "╯" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Quarter {
        "▎" "▔" "🮇"
        "▎"     "🮇"
        "▎" "▁" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    QuarterV {
        "▎" "" "🮇"
        "▎"    "🮇"
        "▎" "" "🮇" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Chamfer {
        "🭂" "▔" "🭍"
        "▎"     "🮇"
        "🭓" "▁" "🭞" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Corners {
        "🬆" "" "🬊" // 🬴 🬸
        ""     ""
        "🬱" "" "🬵" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    CornersTall {
        "🭽" "" "🭾"
        ""     ""
        "🭼" "" "🭿" fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Outer {
        "🭽" "▔" "🭾"
        "▏"     "▕"
        "🭼" "▁" "🭿"
        const W0: &'static str = "[";
        const E0: &'static str = "]";
        const N0: &'static str = "⎴";
        const S0: &'static str = "⎵";
        fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Thick {
        "▄" "▄" "▄"
        "█"     "█"
        "▀" "▀" "▀"
        fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Rugged {
        "▄" "▂" "▄"
        "▐"     "▌"
        "▀" "🮂" "▀"
        fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Skinny {
        "▗" "▄" "▖"
        "▐"     "▌"
        "▝" "▀" "▘"
        fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Brackets {
        "⎡" "" "⎤"
        ""     ""
        "⎣" "" "⎦"
        const W0: &'static str = "[";
        const E0: &'static str = "]";
        const N0: &'static str = "⎴";
        const S0: &'static str = "⎵";
        fn style (&self) -> Option<Style> { Some(self.1) }
    },
    Reticle {
        "⎡" "" "⎤"
        ""     ""
        "⎣" "" "⎦"
        const W0: &'static str = "╟";
        const E0: &'static str = "╢";
        const N0: &'static str = "┯";
        const S0: &'static str = "┷";
        fn style (&self) -> Option<Style> { Some(self.1) }
    }
}

pub trait BorderStyle: Draw<Tui> + Copy {
    fn enabled   (&self) -> bool;
    fn border_n  (&self) -> &str { Self::N  }
    fn border_s  (&self) -> &str { Self::S  }
    fn border_e  (&self) -> &str { Self::E  }
    fn border_w  (&self) -> &str { Self::W  }
    fn border_nw (&self) -> &str { Self::NW }
    fn border_ne (&self) -> &str { Self::NE }
    fn border_sw (&self) -> &str { Self::SW }
    fn border_se (&self) -> &str { Self::SE }

    #[inline] fn draw <'a> (self, to: &mut Tui) -> Usually<XYWH<u16>> {
        if self.enabled() {
            self.draw_h(to, None)?;
            self.draw_v(to, None)?;
            self.draw_c(to, None)?;
        }
        Ok(to.1)
    }
    #[inline] fn draw_h (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
        let style = style.or_else(||self.style_horizontal());
        let y1 = to.y_north();
        let y2 = to.y_south().saturating_sub(1);
        for x in to.x_west()..to.x_east().saturating_sub(1) {
            to.blit(&Self::N, x, y1, style);
            to.blit(&Self::S, x, y2, style)
        }
        Ok(to.xywh())
    }
    #[inline] fn draw_v (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
        let area = to.1;
        let style = style.or_else(||self.style_vertical());
        let [x, x2, y, y2] = area.lrtb();
        let h = y2 - y;
        if h > 1 {
            for y in y..y2.saturating_sub(1) {
                to.blit(&Self::W, x, y, style);
                to.blit(&Self::E, x2.saturating_sub(1), y, style);
            }
        } else if h > 0 {
            to.blit(&Self::W0, x, y, style);
            to.blit(&Self::E0, x2.saturating_sub(1), y, style);
        }
        Ok(area)
    }
    #[inline] fn draw_c (self, to: &mut Tui, style: Option<Style>) -> Usually<XYWH<u16>> {
        let area = to.1;
        let style = style.or_else(||self.style_corners());
        let XYWH(x, y, w, h) = area;
        if w > 1 && h > 1 {
            to.blit(&Self::NW, x, y, style);
            to.blit(&Self::NE, x + w - 1, y, style);
            to.blit(&Self::SW, x, y + h- 1, style);
            to.blit(&Self::SE, x + w - 1, y + h - 1, style);
        }
        Ok(area)
    }
    #[inline] fn style            (&self) -> Option<Style> { None }
    #[inline] fn style_horizontal (&self) -> Option<Style> { self.style() }
    #[inline] fn style_vertical   (&self) -> Option<Style> { self.style() }
    #[inline] fn style_corners    (&self) -> Option<Style> { self.style() }

    const NW: &'static str = "";
    const N:  &'static str = "";
    const NE: &'static str = "";
    const E:  &'static str = "";
    const SE: &'static str = "";
    const S:  &'static str = "";
    const SW: &'static str = "";
    const W:  &'static str = "";

    const N0: &'static str = "";
    const S0: &'static str = "";
    const W0: &'static str = "";
    const E0: &'static str = "";
}