# type: ignore

import pytest

from mycli.packages import special
from mycli.packages.completion_engine import (
    _find_doubled_backticks,
    is_inside_quotes,
    suggest_type,
)


def sorted_dicts(dicts):
    """input is a list of dicts."""
    return sorted(tuple(x.items()) for x in dicts)


def test_select_suggests_cols_with_visible_table_scope():
    suggestions = suggest_type("SELECT  FROM tabl", "SELECT ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_select_suggests_cols_with_qualified_table_scope():
    suggestions = suggest_type("SELECT  FROM sch.tabl", "SELECT ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [("sch", "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM tabl WHERE ",
        "SELECT * FROM tabl WHERE (",
        "SELECT * FROM tabl WHERE bar OR ",
        "SELECT * FROM tabl WHERE foo = 1 AND ",
        "SELECT * FROM tabl WHERE (bar > 10 AND ",
        "SELECT * FROM tabl WHERE (bar AND (baz OR (qux AND (",
        "SELECT * FROM tabl WHERE 10 < ",
        "SELECT * FROM tabl WHERE foo BETWEEN ",
        "SELECT * FROM tabl WHERE foo BETWEEN foo AND ",
    ],
)
def test_where_suggests_columns_functions(expression):
    suggestions = suggest_type(expression, expression)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_where_equals_suggests_enum_values_first():
    expression = "SELECT * FROM tabl WHERE foo = "
    suggestions = suggest_type(expression, expression)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "enum_value", "tables": [(None, "tabl", None)], "column": "foo", "parent": None},
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM tabl WHERE foo IN (",
        "SELECT * FROM tabl WHERE foo IN (bar, ",
    ],
)
def test_where_in_suggests_columns(expression):
    suggestions = suggest_type(expression, expression)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_where_equals_any_suggests_columns_or_keywords():
    text = "SELECT * FROM tabl WHERE foo = ANY("
    suggestions = suggest_type(text, text)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_lparen_suggests_cols():
    suggestion = suggest_type("SELECT MAX( FROM tbl", "SELECT MAX(")
    assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}]


def test_operand_inside_function_suggests_cols1():
    suggestion = suggest_type("SELECT MAX(col1 +  FROM tbl", "SELECT MAX(col1 + ")
    assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}]


def test_operand_inside_function_suggests_cols2():
    suggestion = suggest_type("SELECT MAX(col1 + col2 +  FROM tbl", "SELECT MAX(col1 + col2 + ")
    assert suggestion == [{"type": "column", "tables": [(None, "tbl", None)]}]


def test_select_suggests_cols_and_funcs():
    suggestions = suggest_type("SELECT ", "SELECT ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": []},
        {"type": "column", "tables": []},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM ",
        "INSERT INTO ",
        "COPY ",
        "UPDATE ",
        "DESCRIBE ",
        "DESC ",
        "EXPLAIN ",
        "SELECT * FROM foo JOIN ",
    ],
)
def test_expression_suggests_tables_views_and_schemas(expression):
    suggestions = suggest_type(expression, expression)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
        {"type": "database"},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM sch.",
        "INSERT INTO sch.",
        "COPY sch.",
        "UPDATE sch.",
        "DESCRIBE sch.",
        "DESC sch.",
        "EXPLAIN sch.",
        "SELECT * FROM foo JOIN sch.",
    ],
)
def test_expression_suggests_qualified_tables_views_and_schemas(expression):
    suggestions = suggest_type(expression, expression)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": "sch"},
        {"type": "view", "schema": "sch"},
    ])


def test_truncate_suggests_tables_and_schemas():
    suggestions = suggest_type("TRUNCATE ", "TRUNCATE ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": []},
        {"type": "database"},
    ])


def test_truncate_suggests_qualified_tables():
    suggestions = suggest_type("TRUNCATE sch.", "TRUNCATE sch.")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": "sch"},
    ])


def test_distinct_suggests_cols():
    suggestions = suggest_type("SELECT DISTINCT ", "SELECT DISTINCT ")
    assert suggestions == [{"type": "column", "tables": []}]


def test_col_comma_suggests_cols():
    suggestions = suggest_type("SELECT a, b, FROM tbl", "SELECT a, b,")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tbl"]},
        {"type": "column", "tables": [(None, "tbl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_table_comma_suggests_tables_and_schemas():
    suggestions = suggest_type("SELECT a, b FROM tbl1, ", "SELECT a, b FROM tbl1, ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])


def test_into_suggests_tables_and_schemas():
    suggestion = suggest_type("INSERT INTO ", "INSERT INTO ")
    assert sorted_dicts(suggestion) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])


def test_insert_into_lparen_suggests_cols():
    suggestions = suggest_type("INSERT INTO abc (", "INSERT INTO abc (")
    assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}]


def test_insert_into_lparen_partial_text_suggests_cols():
    suggestions = suggest_type("INSERT INTO abc (i", "INSERT INTO abc (i")
    assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}]


def test_insert_into_lparen_comma_suggests_cols():
    suggestions = suggest_type("INSERT INTO abc (id,", "INSERT INTO abc (id,")
    assert suggestions == [{"type": "column", "tables": [(None, "abc", None)]}]


def test_partially_typed_col_name_suggests_col_names():
    suggestions = suggest_type("SELECT * FROM tabl WHERE col_n", "SELECT * FROM tabl WHERE col_n")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["tabl"]},
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_dot_suggests_cols_of_a_table_or_schema_qualified_table():
    suggestions = suggest_type("SELECT tabl. FROM tabl", "SELECT tabl.")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "tabl", None)]},
        {"type": "table", "schema": "tabl"},
        {"type": "view", "schema": "tabl"},
        {"type": "function", "schema": "tabl"},
    ])


def test_dot_suggests_cols_of_an_alias():
    suggestions = suggest_type("SELECT t1. FROM tabl1 t1, tabl2 t2", "SELECT t1.")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": "t1"},
        {"type": "view", "schema": "t1"},
        {"type": "column", "tables": [(None, "tabl1", "t1")]},
        {"type": "function", "schema": "t1"},
    ])


def test_dot_col_comma_suggests_cols_or_schema_qualified_table():
    suggestions = suggest_type("SELECT t1.a, t2. FROM tabl1 t1, tabl2 t2", "SELECT t1.a, t2.")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "tabl2", "t2")]},
        {"type": "table", "schema": "t2"},
        {"type": "view", "schema": "t2"},
        {"type": "function", "schema": "t2"},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM (",
        "SELECT * FROM foo WHERE EXISTS (",
        "SELECT * FROM foo WHERE bar AND NOT EXISTS (",
        "SELECT 1 AS",
    ],
)
def test_sub_select_suggests_keyword(expression):
    suggestion = suggest_type(expression, expression)
    assert suggestion == [{"type": "keyword"}]


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM (S",
        "SELECT * FROM foo WHERE EXISTS (S",
        "SELECT * FROM foo WHERE bar AND NOT EXISTS (S",
    ],
)
def test_sub_select_partial_text_suggests_keyword(expression):
    suggestion = suggest_type(expression, expression)
    assert suggestion == [{"type": "keyword"}]


def test_outer_table_reference_in_exists_subquery_suggests_columns():
    q = "SELECT * FROM foo f WHERE EXISTS (SELECT 1 FROM bar WHERE f."
    suggestions = suggest_type(q, q)
    assert suggestions == [
        {"type": "column", "tables": [(None, "foo", "f")]},
        {"type": "table", "schema": "f"},
        {"type": "view", "schema": "f"},
        {"type": "function", "schema": "f"},
    ]


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT * FROM (SELECT * FROM ",
        "SELECT * FROM foo WHERE EXISTS (SELECT * FROM ",
        "SELECT * FROM foo WHERE bar AND NOT EXISTS (SELECT * FROM ",
    ],
)
def test_sub_select_table_name_completion(expression):
    suggestion = suggest_type(expression, expression)
    assert sorted_dicts(suggestion) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])


def test_sub_select_col_name_completion():
    suggestions = suggest_type("SELECT * FROM (SELECT  FROM abc", "SELECT * FROM (SELECT ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["abc"]},
        {"type": "column", "tables": [(None, "abc", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


@pytest.mark.xfail
def test_sub_select_multiple_col_name_completion():
    suggestions = suggest_type("SELECT * FROM (SELECT a, FROM abc", "SELECT * FROM (SELECT a, ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "abc", None)]},
        {"type": "function", "schema": []},
    ])


def test_sub_select_dot_col_name_completion():
    suggestions = suggest_type("SELECT * FROM (SELECT t. FROM tabl t", "SELECT * FROM (SELECT t.")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "tabl", "t")]},
        {"type": "table", "schema": "t"},
        {"type": "view", "schema": "t"},
        {"type": "function", "schema": "t"},
    ])


@pytest.mark.parametrize("join_type", ["", "INNER", "LEFT", "RIGHT OUTER"])
@pytest.mark.parametrize("tbl_alias", ["", "foo"])
def test_join_suggests_tables_and_schemas(tbl_alias, join_type):
    text = f"SELECT * FROM abc {tbl_alias} {join_type} JOIN "
    suggestion = suggest_type(text, text)
    assert sorted_dicts(suggestion) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])


@pytest.mark.parametrize(
    "sql",
    [
        "SELECT * FROM abc a JOIN def d ON a.",
        "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.",
    ],
)
def test_join_alias_dot_suggests_cols1(sql):
    suggestions = suggest_type(sql, sql)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "abc", "a")]},
        {"type": "table", "schema": "a"},
        {"type": "view", "schema": "a"},
        {"type": "function", "schema": "a"},
    ])


@pytest.mark.parametrize(
    "sql",
    [
        "SELECT * FROM abc a JOIN def d ON a.id = d.",
        "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.id2 = d.",
    ],
)
def test_join_alias_dot_suggests_cols2(sql):
    suggestions = suggest_type(sql, sql)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "def", "d")]},
        {"type": "table", "schema": "d"},
        {"type": "view", "schema": "d"},
        {"type": "function", "schema": "d"},
    ])


@pytest.mark.parametrize(
    "sql",
    [
        "select a.x, b.y from abc a join bcd b on ",
        "select a.x, b.y from abc a join bcd b on a.id = b.id OR ",
    ],
)
def test_on_suggests_aliases(sql):
    suggestions = suggest_type(sql, sql)
    assert suggestions == [{"type": "alias", "aliases": ["a", "b"]}]


@pytest.mark.parametrize(
    "sql",
    [
        "select abc.x, bcd.y from abc join bcd on ",
        "select abc.x, bcd.y from abc join bcd on abc.id = bcd.id AND ",
    ],
)
def test_on_suggests_tables(sql):
    suggestions = suggest_type(sql, sql)
    assert suggestions == [{"type": "alias", "aliases": ["abc", "bcd"]}]


@pytest.mark.parametrize(
    "sql",
    [
        "select a.x, b.y from abc a join bcd b on a.id = ",
        "select a.x, b.y from abc a join bcd b on a.id = b.id AND a.id2 = ",
    ],
)
def test_on_suggests_aliases_right_side(sql):
    suggestions = suggest_type(sql, sql)
    assert suggestions == [{"type": "alias", "aliases": ["a", "b"]}]


@pytest.mark.parametrize(
    "sql",
    [
        "select abc.x, bcd.y from abc join bcd on ",
        "select abc.x, bcd.y from abc join bcd on abc.id = bcd.id and ",
    ],
)
def test_on_suggests_tables_right_side(sql):
    suggestions = suggest_type(sql, sql)
    assert suggestions == [{"type": "alias", "aliases": ["abc", "bcd"]}]


@pytest.mark.parametrize("col_list", ["", "col1, "])
def test_join_using_suggests_common_columns(col_list):
    text = "select * from abc inner join def using (" + col_list
    assert suggest_type(text, text) == [{"type": "column", "tables": [(None, "abc", None), (None, "def", None)], "drop_unique": True}]


@pytest.mark.parametrize(
    "sql",
    [
        "SELECT * FROM abc a JOIN def d ON a.id = d.id JOIN ghi g ON g.",
        "SELECT * FROM abc a JOIN def d ON a.id = d.id AND a.id2 = d.id2 JOIN ghi g ON d.id = g.id AND g.",
    ],
)
def test_two_join_alias_dot_suggests_cols1(sql):
    suggestions = suggest_type(sql, sql)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "column", "tables": [(None, "ghi", "g")]},
        {"type": "table", "schema": "g"},
        {"type": "view", "schema": "g"},
        {"type": "function", "schema": "g"},
    ])


def test_2_statements_2nd_current():
    suggestions = suggest_type("select * from a; select * from ", "select * from a; select * from ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
        {"type": "database"},
    ])

    suggestions = suggest_type("select * from a; select  from b", "select * from a; select ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["b"]},
        {"type": "column", "tables": [(None, "b", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])

    # Should work even if first statement is invalid
    suggestions = suggest_type("select * from; select * from ", "select * from; select * from ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
        {"type": "database"},
    ])


def test_2_statements_1st_current():
    suggestions = suggest_type("select * from ; select * from b", "select * from ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])

    suggestions = suggest_type("select  from a; select * from b", "select ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["a"]},
        {"type": "column", "tables": [(None, "a", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_3_statements_2nd_current():
    suggestions = suggest_type("select * from a; select * from ; select * from c", "select * from a; select * from ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])

    suggestions = suggest_type("select * from a; select  from b; select * from c", "select * from a; select ")
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "alias", "aliases": ["b"]},
        {"type": "column", "tables": [(None, "b", None)]},
        {"type": "function", "schema": []},
        {"type": "keyword"},
    ])


def test_create_db_with_template():
    suggestions = suggest_type("create database foo with template ", "create database foo with template ")

    assert sorted_dicts(suggestions) == sorted_dicts([{"type": "database"}])


@pytest.mark.parametrize("initial_text", ["", "    ", "\t \t"])
def test_specials_included_for_initial_completion(initial_text):
    suggestions = suggest_type(initial_text, initial_text)

    assert sorted_dicts(suggestions) == sorted_dicts([{"type": "keyword"}, {"type": "special"}])


@pytest.mark.parametrize('initial_text', ['REDIRECT'])
def test_specials_included_with_caps(initial_text):
    suggestions = suggest_type(initial_text, initial_text)

    assert sorted_dicts(suggestions) == sorted_dicts([{'type': 'keyword'}, {'type': 'special'}])


def test_specials_not_included_after_initial_token():
    suggestions = suggest_type("create table foo (dt d", "create table foo (dt d")

    assert sorted_dicts(suggestions) == sorted_dicts([{"type": "keyword"}])


def test_drop_schema_qualified_table_suggests_only_tables():
    text = "DROP TABLE schema_name.table_name"
    suggestions = suggest_type(text, text)
    assert suggestions == [{"type": "table", "schema": "schema_name"}]


@pytest.mark.parametrize("text", [",", "  ,", "sel ,"])
def test_handle_pre_completion_comma_gracefully(text):
    suggestions = suggest_type(text, text)

    assert iter(suggestions)


def test_cross_join():
    text = "select * from v1 cross join v2 JOIN v1.id, "
    suggestions = suggest_type(text, text)
    assert sorted_dicts(suggestions) == sorted_dicts([
        {"type": "database"},
        {"type": "table", "schema": []},
        {"type": "view", "schema": []},
    ])


@pytest.mark.parametrize(
    "expression",
    [
        "SELECT 1 AS ",
        "SELECT 1 FROM tabl AS ",
    ],
)
def test_after_as(expression):
    suggestions = suggest_type(expression, expression)
    assert set(suggestions) == set()


@pytest.mark.parametrize(
    "expression",
    [
        "\\. ",
        "select 1; \\. ",
        "select 1;\\. ",
        "select 1 ; \\. ",
        "source ",
        "truncate table test; source ",
        "truncate table test ; source ",
        "truncate table test;source ",
    ],
)
def test_source_is_file(expression):
    # "source" has to be registered by hand because that usually happens inside MyCLI in mycli/main.py
    special.register_special_command(..., 'source', '\\. filename', 'Execute commands from file.', aliases=['\\.'])
    suggestions = suggest_type(expression, expression)
    assert suggestions == [{"type": "file_name"}]


@pytest.mark.parametrize(
    "expression",
    [
        "\\f ",
    ],
)
def test_favorite_name_suggestion(expression):
    suggestions = suggest_type(expression, expression)
    assert suggestions == [{"type": "favoritequery"}]


def test_order_by():
    text = "select * from foo order by "
    suggestions = suggest_type(text, text)
    assert suggestions == [{"tables": [(None, "foo", None)], "type": "column"}]


def test_quoted_where():
    text = "'where i=';"
    suggestions = suggest_type(text, text)
    assert suggestions == [{"type": "keyword"}]


def test_find_doubled_backticks_none():
    text = 'select `ab`'
    assert _find_doubled_backticks(text) == []


def test_find_doubled_backticks_some():
    text = 'select `a``b`'
    assert _find_doubled_backticks(text) == [9, 10]


def test_inside_quotes_01():
    text = "select '"
    assert is_inside_quotes(text, len(text)) == 'single'


def test_inside_quotes_02():
    text = "select '\\'"
    assert is_inside_quotes(text, len(text)) == 'single'


def test_inside_quotes_03():
    text = "select '`"
    assert is_inside_quotes(text, len(text)) == 'single'


def test_inside_quotes_04():
    text = 'select "'
    assert is_inside_quotes(text, len(text)) == 'double'


def test_inside_quotes_05():
    text = 'select "\\"\''
    assert is_inside_quotes(text, len(text)) == 'double'


def test_inside_quotes_06():
    text = 'select ""'
    assert is_inside_quotes(text, len(text)) is False


@pytest.mark.parametrize(
    ["text", "position", "expected"],
    [
        ("select `'",      len("select `'"),  'backtick'),
        ("select `' ",     len("select `' "), 'backtick'),
        ("select `'",      -1,  'backtick'),
        ("select `'",      -2,  False),
        ('select `ab` ',   -1,  False),
        ('select `ab` ',   -2,  'backtick'),
        ('select `a``b` ', -1,  False),
        ('select `a``b` ', -2,  'backtick'),
        ('select `a``b` ', -3,  'backtick'),
        ('select `a``b` ', -4,  'backtick'),
        ('select `a``b` ', -5,  'backtick'),
        ('select `a``b` ', -6,  'backtick'),
        ('select `a``b` ', -7,  False),
    ]
)  # fmt: skip
def test_inside_quotes_backtick_01(text, position, expected):
    assert is_inside_quotes(text, position) == expected


def test_inside_quotes_backtick_02():
    """Empty backtick pairs are treated as a doubled (escaped) backtick.
    This is okay because it is invalid SQL, and we don't have to complete on it.
    """
    text = 'select ``'
    assert is_inside_quotes(text, -1) is False


def test_inside_quotes_backtick_03():
    """Empty backtick pairs are treated as a doubled (escaped) backtick.
    This is okay because it is invalid SQL, and we don't have to complete on it.
    """
    text = 'select ``'
    assert is_inside_quotes(text, -2) is False
