//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11
// UNSUPPORTED: libcpp-has-no-localization

// <iomanip>

// quoted

#include <iomanip>
#include <sstream>
#include <string_view>
#include <cassert>

#include "test_macros.h"

bool is_skipws ( const std::istream *is ) {
    return ( is->flags() & std::ios_base::skipws ) != 0;
}

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
bool is_skipws ( const std::wistream *is ) {
    return ( is->flags() & std::ios_base::skipws ) != 0;
}
#endif

void round_trip ( const char *p ) {
    std::stringstream ss;
    bool skippingws = is_skipws ( &ss );
    std::string_view sv {p};

    ss << std::quoted(sv);
    std::string s;
    ss >> std::quoted(s);
    assert ( s == sv );
    assert ( skippingws == is_skipws ( &ss ));
    }

void round_trip_ws ( const char *p ) {
    std::stringstream ss;
    std::noskipws ( ss );
    bool skippingws = is_skipws ( &ss );
    std::string_view sv {p};

    ss << std::quoted(sv);
    std::string s;
    ss >> std::quoted(s);
    assert ( s == sv );
    assert ( skippingws == is_skipws ( &ss ));
    }

void round_trip_d ( const char *p, char delim ) {
    std::stringstream ss;
    std::string_view sv {p};

    ss << std::quoted(sv, delim);
    std::string s;
    ss >> std::quoted(s, delim);
    assert ( s == sv );
    }

void round_trip_e ( const char *p, char escape ) {
    std::stringstream ss;
    std::string_view sv {p};

    ss << std::quoted(sv, '"', escape );
    std::string s;
    ss >> std::quoted(s, '"', escape );
    assert ( s == sv );
    }



std::string quote ( const char *p, char delim='"', char escape='\\' ) {
    std::stringstream ss;
    ss << std::quoted(p, delim, escape);
    std::string s;
    ss >> s;    // no quote
    return s;
}

std::string unquote ( const char *p, char delim='"', char escape='\\' ) {
    std::stringstream ss;
    ss << p;
    std::string s;
    ss >> std::quoted(s, delim, escape);
    return s;
}

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
void round_trip ( const wchar_t *p ) {
    std::wstringstream ss;
    bool skippingws = is_skipws ( &ss );
    std::wstring_view sv {p};

    ss << std::quoted(sv);
    std::wstring s;
    ss >> std::quoted(s);
    assert ( s == sv );
    assert ( skippingws == is_skipws ( &ss ));
    }


void round_trip_ws ( const wchar_t *p ) {
    std::wstringstream ss;
    std::noskipws ( ss );
    bool skippingws = is_skipws ( &ss );
    std::wstring_view sv {p};

    ss << std::quoted(sv);
    std::wstring s;
    ss >> std::quoted(s);
    assert ( s == sv );
    assert ( skippingws == is_skipws ( &ss ));
    }

void round_trip_d ( const wchar_t *p, wchar_t delim ) {
    std::wstringstream ss;
    std::wstring_view sv {p};

    ss << std::quoted(sv, delim);
    std::wstring s;
    ss >> std::quoted(s, delim);
    assert ( s == sv );
    }

void round_trip_e ( const wchar_t *p, wchar_t escape ) {
    std::wstringstream ss;
    std::wstring_view sv {p};

    ss << std::quoted(sv, wchar_t('"'), escape );
    std::wstring s;
    ss >> std::quoted(s, wchar_t('"'), escape );
    assert ( s == sv );
    }


std::wstring quote ( const wchar_t *p, wchar_t delim='"', wchar_t escape='\\' ) {
    std::wstringstream ss;
    std::wstring_view sv {p};

    ss << std::quoted(sv, delim, escape);
    std::wstring s;
    ss >> s;    // no quote
    return s;
}

std::wstring unquote ( const wchar_t *p, wchar_t delim='"', wchar_t escape='\\' ) {
    std::wstringstream ss;
    std::wstring_view sv {p};

    ss << sv;
    std::wstring s;
    ss >> std::quoted(s, delim, escape);
    return s;
}
#endif // TEST_HAS_NO_WIDE_CHARACTERS

int main(int, char**)
{
    round_trip    (  "" );
    round_trip_ws (  "" );
    round_trip_d  (  "", 'q' );
    round_trip_e  (  "", 'q' );

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
    round_trip    ( L"" );
    round_trip_ws ( L"" );
    round_trip_d  ( L"", 'q' );
    round_trip_e  ( L"", 'q' );
#endif

    round_trip    (  "Hi" );
    round_trip_ws (  "Hi" );
    round_trip_d  (  "Hi", '!' );
    round_trip_e  (  "Hi", '!' );
    assert ( quote ( "Hi", '!' ) == "!Hi!" );
    assert ( quote ( "Hi!", '!' ) == R"(!Hi\!!)" );

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
    round_trip    ( L"Hi" );
    round_trip_ws ( L"Hi" );
    round_trip_d  ( L"Hi", '!' );
    round_trip_e  ( L"Hi", '!' );
    assert ( quote ( L"Hi", '!' )  == L"!Hi!" );
    assert ( quote ( L"Hi!", '!' ) == LR"(!Hi\!!)" );
#endif

    round_trip    (  "Hi Mom" );
    round_trip_ws (  "Hi Mom" );

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
    round_trip    ( L"Hi Mom" );
    round_trip_ws ( L"Hi Mom" );
#endif

    assert ( quote (  "" )  ==  "\"\"" );
    assert ( quote (  "a" ) ==  "\"a\"" );
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
    assert ( quote ( L"" )  == L"\"\"" );
    assert ( quote ( L"a" ) == L"\"a\"" );
#endif

    // missing end quote - must not hang
    assert ( unquote (  "\"abc" ) ==  "abc" );
    assert ( unquote (  "abc" ) == "abc" ); // no delimiter
    assert ( unquote (  "abc def" ) ==  "abc" ); // no delimiter
    assert ( unquote (  "" ) ==  "" ); // nothing there

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
    assert ( unquote ( L"\"abc" ) == L"abc" );
    assert ( unquote ( L"abc" ) == L"abc" ); // no delimiter
    assert ( unquote ( L"abc def" ) == L"abc" ); // no delimiter
    assert ( unquote ( L"" ) == L"" ); // nothing there
#endif

    return 0;
}
