/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use cssparser::SourceLocation;
use rayon;
use servo_arc::Arc;
use servo_url::ServoUrl;
use style::context::QuirksMode;
use style::error_reporting::{ContextualParseError, ParseErrorReporter};
use style::media_queries::MediaList;
use style::properties::{longhands, Importance, PropertyDeclaration, PropertyDeclarationBlock};
use style::rule_tree::{CascadeLevel, RuleTree, StrongRuleNode, StyleSource};
use style::shared_lock::SharedRwLock;
use style::stylesheets::{CssRule, Origin, Stylesheet};
use style::thread_state::{self, ThreadState};
use test::{self, Bencher};

struct ErrorringErrorReporter;
impl ParseErrorReporter for ErrorringErrorReporter {
    fn report_error(&self, url: &ServoUrl, location: SourceLocation, error: ContextualParseError) {
        panic!(
            "CSS error: {}\t\n{}:{} {}",
            url.as_str(),
            location.line,
            location.column,
            error
        );
    }
}

struct AutoGCRuleTree<'a>(&'a RuleTree);

impl<'a> AutoGCRuleTree<'a> {
    fn new(r: &'a RuleTree) -> Self {
        AutoGCRuleTree(r)
    }
}

impl<'a> Drop for AutoGCRuleTree<'a> {
    fn drop(&mut self) {
        unsafe {
            self.0.gc();
            assert!(
                ::std::thread::panicking() || !self.0.root().has_children_for_testing(),
                "No rule nodes other than the root shall remain!"
            );
        }
    }
}

fn parse_rules(css: &str) -> Vec<(StyleSource, CascadeLevel)> {
    let lock = SharedRwLock::new();
    let media = Arc::new(lock.wrap(MediaList::empty()));

    let s = Stylesheet::from_str(
        css,
        ServoUrl::parse("http://localhost").unwrap(),
        Origin::Author,
        media,
        lock,
        None,
        Some(&ErrorringErrorReporter),
        QuirksMode::NoQuirks,
        0,
    );
    let guard = s.shared_lock.read();
    let rules = s.contents.rules.read_with(&guard);
    rules
        .0
        .iter()
        .filter_map(|rule| match *rule {
            CssRule::Style(ref style_rule) => Some((
                StyleSource::from_rule(style_rule.clone()),
                CascadeLevel::UserNormal,
            )),
            _ => None,
        })
        .collect()
}

fn test_insertion(rule_tree: &RuleTree, rules: Vec<(StyleSource, CascadeLevel)>) -> StrongRuleNode {
    rule_tree.insert_ordered_rules(rules.into_iter())
}

fn test_insertion_style_attribute(
    rule_tree: &RuleTree,
    rules: &[(StyleSource, CascadeLevel)],
    shared_lock: &SharedRwLock,
) -> StrongRuleNode {
    let mut rules = rules.to_vec();
    rules.push((
        StyleSource::from_declarations(Arc::new(shared_lock.wrap(
            PropertyDeclarationBlock::with_one(
                PropertyDeclaration::Display(longhands::display::SpecifiedValue::Block),
                Importance::Normal,
            ),
        ))),
        CascadeLevel::UserNormal,
    ));
    test_insertion(rule_tree, rules)
}

#[bench]
fn bench_insertion_basic(b: &mut Bencher) {
    let r = RuleTree::new();
    thread_state::initialize(ThreadState::SCRIPT);

    let rules_matched = parse_rules(
        ".foo { width: 200px; } \
         .bar { height: 500px; } \
         .baz { display: block; }",
    );

    b.iter(|| {
        let _gc = AutoGCRuleTree::new(&r);

        for _ in 0..(4000 + 400) {
            test::black_box(test_insertion(&r, rules_matched.clone()));
        }
    })
}

#[bench]
fn bench_insertion_basic_per_element(b: &mut Bencher) {
    let r = RuleTree::new();
    thread_state::initialize(ThreadState::SCRIPT);

    let rules_matched = parse_rules(
        ".foo { width: 200px; } \
         .bar { height: 500px; } \
         .baz { display: block; }",
    );

    b.iter(|| {
        let _gc = AutoGCRuleTree::new(&r);

        test::black_box(test_insertion(&r, rules_matched.clone()));
    });
}

#[bench]
fn bench_expensive_insertion(b: &mut Bencher) {
    let r = RuleTree::new();
    thread_state::initialize(ThreadState::SCRIPT);

    // This test case tests a case where you style a bunch of siblings
    // matching the same rules, with a different style attribute each
    // one.
    let rules_matched = parse_rules(
        ".foo { width: 200px; } \
         .bar { height: 500px; } \
         .baz { display: block; }",
    );

    let shared_lock = SharedRwLock::new();
    b.iter(|| {
        let _gc = AutoGCRuleTree::new(&r);

        for _ in 0..(4000 + 400) {
            test::black_box(test_insertion_style_attribute(
                &r,
                &rules_matched,
                &shared_lock,
            ));
        }
    });
}

#[bench]
fn bench_insertion_basic_parallel(b: &mut Bencher) {
    let r = RuleTree::new();
    thread_state::initialize(ThreadState::SCRIPT);

    let rules_matched = parse_rules(
        ".foo { width: 200px; } \
         .bar { height: 500px; } \
         .baz { display: block; }",
    );

    b.iter(|| {
        let _gc = AutoGCRuleTree::new(&r);

        rayon::scope(|s| {
            for _ in 0..4 {
                s.spawn(|s| {
                    for _ in 0..1000 {
                        test::black_box(test_insertion(&r, rules_matched.clone()));
                    }
                    s.spawn(|_| {
                        for _ in 0..100 {
                            test::black_box(test_insertion(&r, rules_matched.clone()));
                        }
                    })
                })
            }
        });
    });
}

#[bench]
fn bench_expensive_insertion_parallel(b: &mut Bencher) {
    let r = RuleTree::new();
    thread_state::initialize(ThreadState::SCRIPT);

    let rules_matched = parse_rules(
        ".foo { width: 200px; } \
         .bar { height: 500px; } \
         .baz { display: block; }",
    );

    let shared_lock = SharedRwLock::new();
    b.iter(|| {
        let _gc = AutoGCRuleTree::new(&r);

        rayon::scope(|s| {
            for _ in 0..4 {
                s.spawn(|s| {
                    for _ in 0..1000 {
                        test::black_box(test_insertion_style_attribute(
                            &r,
                            &rules_matched,
                            &shared_lock,
                        ));
                    }
                    s.spawn(|_| {
                        for _ in 0..100 {
                            test::black_box(test_insertion_style_attribute(
                                &r,
                                &rules_matched,
                                &shared_lock,
                            ));
                        }
                    })
                })
            }
        });
    });
}
