/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * License); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include <gtest/gtest.h>

#include <cstdio>
#include <fstream>
#include <sstream>
#include <string>
#ifndef _WIN32
#include <sys/stat.h>
#include <unistd.h>
#endif

#include "cli/run_cli.h"
#include "cli_test_util.h"
#include "reader/tsfile_reader.h"

#ifndef TSFILE_CPP_SOURCE_DIR
#define TSFILE_CPP_SOURCE_DIR "."
#endif

namespace {

struct TableFixture {
    std::string path = tsfile_cli_test::write_table_fixture();
    ~TableFixture() { std::remove(path.c_str()); }
};

struct MultiTableFixture {
    std::string path = tsfile_cli_test::write_multi_table_fixture();
    ~MultiTableFixture() { std::remove(path.c_str()); }
};

bool file_exists(const std::string& path) {
    std::ifstream in(path.c_str());
    return in.good();
}

std::string read_file(const std::string& path) {
    std::ifstream in(path.c_str(), std::ios::binary);
    std::ostringstream buf;
    buf << in.rdbuf();
    return buf.str();
}

}  // namespace

TEST(CliRequirements, HelpListsExactlyCurrentCommandSurface) {
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"--help"}, out, err);
    EXPECT_EQ(code, 0);
    EXPECT_NE(out.str().find(
                  "ls schema meta stats count sketch head cat export write"),
              std::string::npos)
        << out.str();
    EXPECT_EQ(out.str().find("sample"), std::string::npos) << out.str();
    EXPECT_TRUE(err.str().empty());
}

TEST(CliRequirements, CommandHelpIsSpecificAndDocumentsSyntaxFieldsExamples) {
    const std::vector<std::string> commands = {
        "ls",     "schema", "meta", "stats",  "count",
        "sketch", "head",   "cat",  "export", "write"};
    for (const auto& command : commands) {
        std::ostringstream out;
        std::ostringstream err;
        EXPECT_EQ(tsfile_cli::run_cli({command, "--help"}, out, err), 0)
            << command;
        EXPECT_TRUE(err.str().empty()) << command << ": " << err.str();
        EXPECT_NE(out.str().find("Usage: tsfile-cli " + command),
                  std::string::npos)
            << command << ": " << out.str();
        EXPECT_NE(out.str().find("Result fields:"), std::string::npos)
            << command << ": " << out.str();
        EXPECT_NE(out.str().find("Examples:"), std::string::npos)
            << command << ": " << out.str();
        EXPECT_EQ(out.str().find("Commands:"), std::string::npos)
            << command << ": " << out.str();
    }

    std::ostringstream meta_out;
    std::ostringstream meta_err;
    EXPECT_EQ(tsfile_cli::run_cli({"meta", "--help"}, meta_out, meta_err), 0);
    EXPECT_TRUE(meta_err.str().empty());
    EXPECT_NE(meta_out.str().find("Usage: tsfile-cli meta"), std::string::npos)
        << meta_out.str();
    EXPECT_NE(meta_out.str().find("Result fields:"), std::string::npos)
        << meta_out.str();
    EXPECT_NE(meta_out.str().find("size_bytes,format_version,model"),
              std::string::npos)
        << meta_out.str();
    EXPECT_NE(meta_out.str().find("Examples:"), std::string::npos)
        << meta_out.str();
    EXPECT_EQ(meta_out.str().find("Commands:"), std::string::npos)
        << meta_out.str();

    std::ostringstream write_out;
    std::ostringstream write_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "-h"}, write_out, write_err), 0);
    EXPECT_TRUE(write_err.str().empty());
    EXPECT_NE(write_out.str().find("Usage: tsfile-cli write"),
              std::string::npos)
        << write_out.str();
    EXPECT_NE(write_out.str().find("--field <name> <type>"), std::string::npos)
        << write_out.str();
    EXPECT_NE(write_out.str().find("Default: success is silent"),
              std::string::npos)
        << write_out.str();
    EXPECT_NE(write_out.str().find("Examples:"), std::string::npos)
        << write_out.str();
    EXPECT_EQ(write_out.str().find("Commands:"), std::string::npos)
        << write_out.str();
}

TEST(CliRequirements, SkillShipsRequiredReferenceFiles) {
    const std::string root = std::string(TSFILE_CPP_SOURCE_DIR) +
                             "/tools/skills/tsfile-cli/references/";
    const std::vector<std::string> refs = {"commands.md", "errors.md",
                                           "examples.md"};
    for (const auto& ref : refs) {
        std::ifstream in(root + ref);
        ASSERT_TRUE(in.good()) << ref;
        std::ostringstream body;
        body << in.rdbuf();
        EXPECT_NE(body.str().find("tsfile-cli"), std::string::npos)
            << root + ref;
    }
}

TEST(CliRequirements, SampleIsNotACommand) {
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"sample", "x.tsfile"}, out, err);
    EXPECT_EQ(code, 1);
    EXPECT_TRUE(out.str().empty());
    EXPECT_NE(err.str().find("Unknown command"), std::string::npos)
        << err.str();
}

TEST(CliRequirements, VersionIncludesConcreteBuildMetadata) {
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"--version"}, out, err);
    EXPECT_EQ(code, 0);
    EXPECT_TRUE(err.str().empty());
    EXPECT_NE(out.str().find("tsfile-cli "), std::string::npos) << out.str();
    EXPECT_NE(out.str().find(" tsfile="), std::string::npos) << out.str();
    EXPECT_NE(out.str().find(" commit="), std::string::npos) << out.str();
    EXPECT_NE(out.str().find(" built="), std::string::npos) << out.str();
    EXPECT_EQ(out.str().find("unknown"), std::string::npos) << out.str();
}

TEST(CliRequirements, FormatVocabularyIsTableNdjsonCsvOnly) {
    TableFixture f;

    std::ostringstream ndjson_out;
    std::ostringstream ndjson_err;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--start", "0", "--end",
                                   "0", "-f", "ndjson", f.path},
                                  ndjson_out, ndjson_err),
              0)
        << ndjson_err.str();
    EXPECT_EQ(ndjson_out.str(),
              "{\"time\":\"0\",\"id1\":\"id1_field_1\",\"id2\":"
              "\"id2_field_2\",\"s1\":\"0\"}\n");

    std::ostringstream json_out;
    std::ostringstream json_err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"cat", "-f", "json", f.path}, json_out, json_err),
        1);
    EXPECT_TRUE(json_out.str().empty());

    std::ostringstream tsv_out;
    std::ostringstream tsv_err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"cat", "-f", "tsv", f.path}, tsv_out, tsv_err), 1);
    EXPECT_TRUE(tsv_out.str().empty());
}

TEST(CliRequirements, DuplicateSingletonOptionsAreUsageErrors) {
    TableFixture f;
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"cat", "-f", "csv", "-f", "ndjson", f.path},
                                   out, err);
    EXPECT_EQ(code, 1);
    EXPECT_TRUE(out.str().empty());
    EXPECT_NE(err.str().find("--format specified more than once"),
              std::string::npos)
        << err.str();

    const std::vector<std::vector<std::string>> duplicate_singletons = {
        {"cat", "-n", "1", "--limit", "2", f.path},
        {"cat", "--offset", "0", "--offset", "1", f.path},
        {"cat", "--start", "0", "--start", "1", f.path},
        {"cat", "--end", "1", "--end", "2", f.path},
        {"export", "-t", "table1", "--type", "csv", "-o", "a.csv", "--output",
         "b.csv", f.path},
        {"export", "-t", "table1", "--type", "csv", "--output-dir", "a",
         "--output-dir", "b", f.path},
        {"export", "-t", "table1", "--type", "csv", "-o", "a.csv", "--force",
         "--force", f.path},
    };
    for (const std::vector<std::string>& args : duplicate_singletons) {
        std::ostringstream dup_out;
        std::ostringstream dup_err;
        EXPECT_EQ(tsfile_cli::run_cli(args, dup_out, dup_err), 1)
            << dup_err.str();
        EXPECT_TRUE(dup_out.str().empty());
        EXPECT_NE(dup_err.str().find("specified more than once"),
                  std::string::npos)
            << dup_err.str();
    }
}

TEST(CliRequirements, PositionalFileMustBeFinalUnlessAfterDoubleDash) {
    TableFixture f;

    std::ostringstream bad_out;
    std::ostringstream bad_err;
    int bad_code =
        tsfile_cli::run_cli({"cat", f.path, "-f", "csv"}, bad_out, bad_err);
    EXPECT_EQ(bad_code, 1);
    EXPECT_TRUE(bad_out.str().empty());
    EXPECT_NE(bad_err.str().find("Unexpected argument after file"),
              std::string::npos)
        << bad_err.str();

    std::ostringstream ok_out;
    std::ostringstream ok_err;
    int ok_code =
        tsfile_cli::run_cli({"cat", "-m", "s1", "--", f.path}, ok_out, ok_err);
    EXPECT_EQ(ok_code, 0) << ok_err.str();
    EXPECT_TRUE(ok_err.str().empty());
}

TEST(CliRequirements, MeasurementOptionRepeatsAndRejectsCommaLists) {
    TableFixture f;
    std::ostringstream comma_out;
    std::ostringstream comma_err;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1,s2", f.path}, comma_out,
                                  comma_err),
              1);

    std::ostringstream dup_out;
    std::ostringstream dup_err;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-m", "s1", f.path},
                                  dup_out, dup_err),
              1);
    EXPECT_NE(dup_err.str().find("specified more than once"), std::string::npos)
        << dup_err.str();
}

TEST(CliRequirements, MetaOnlyReturnsSizeFormatVersionAndModel) {
    TableFixture f;
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"meta", "-f", "csv", f.path}, out, err);
    EXPECT_EQ(code, 0) << err.str();
    EXPECT_TRUE(err.str().empty());
    EXPECT_EQ(out.str().substr(
                  0, std::string("size_bytes,format_version,model\n").size()),
              "size_bytes,format_version,model\n")
        << out.str();
    EXPECT_EQ(out.str().find("path"), std::string::npos) << out.str();
    EXPECT_EQ(out.str().find("device_count"), std::string::npos) << out.str();
}

TEST(CliRequirements, LsReturnsModelAndObjectFields) {
    TableFixture f;
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"ls", "-f", "csv", f.path}, out, err);
    EXPECT_EQ(code, 0) << err.str();
    EXPECT_EQ(out.str(), "model,object\ntable,table1\n");
}

TEST(CliRequirements, SchemaReturnsFixedSevenFieldContract) {
    TableFixture f;
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"schema", "-f", "csv", f.path}, out, err);
    EXPECT_EQ(code, 0) << err.str();
    EXPECT_EQ(out.str().substr(
                  0, std::string("model,object,column,category,data_type,"
                                 "encoding,compression\n")
                         .size()),
              "model,object,column,category,data_type,encoding,compression\n")
        << out.str();
    EXPECT_NE(out.str().find("table,table1,id1,TAG,STRING"), std::string::npos)
        << out.str();
    EXPECT_NE(out.str().find("table,table1,s1,FIELD,INT64"), std::string::npos)
        << out.str();
}

TEST(CliRequirements, HeadCatAndExportRejectOffsetWithZeroLimit) {
    TableFixture f;
    std::string out_path = tsfile_cli_test::unique_temp_path(
        "tsfile_cli_zero_limit_export", ".csv");

    std::ostringstream head_out;
    std::ostringstream head_err;
    EXPECT_EQ(tsfile_cli::run_cli({"head", "-n", "0", "--offset", "1", f.path},
                                  head_out, head_err),
              1);
    EXPECT_TRUE(head_out.str().empty());

    std::ostringstream cat_out;
    std::ostringstream cat_err;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-n", "0", "--offset", "1", f.path},
                                  cat_out, cat_err),
              1);
    EXPECT_TRUE(cat_out.str().empty());

    std::ostringstream export_out;
    std::ostringstream export_err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"export", "-t", "table1", "--type", "csv", "-o",
                             out_path, "-n", "0", "--offset", "1", f.path},
                            export_out, export_err),
        1);
    EXPECT_TRUE(export_out.str().empty());
    EXPECT_FALSE(file_exists(out_path));
    std::remove(out_path.c_str());
}

TEST(CliRequirements, HeadAndCatRequireScopeForMultiObjectFiles) {
    MultiTableFixture f;

    std::ostringstream cat_out;
    std::ostringstream cat_err;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", f.path},
                                  cat_out, cat_err),
              1);
    EXPECT_TRUE(cat_out.str().empty());
    EXPECT_NE(cat_err.str().find("requires -t/--table"), std::string::npos)
        << cat_err.str();

    std::ostringstream head_out;
    std::ostringstream head_err;
    EXPECT_EQ(tsfile_cli::run_cli({"head", "-m", "s1", "-f", "csv", f.path},
                                  head_out, head_err),
              1);
    EXPECT_TRUE(head_out.str().empty());
    EXPECT_NE(head_err.str().find("requires -t/--table"), std::string::npos)
        << head_err.str();
}

TEST(CliRequirements, WriteUsesExplicitTagAndFieldOptions) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_req_in", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "time,id1,s1\n0,dev,0\n1,dev,10\n";
    }
    std::string out_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_req_out", ".tsfile");

    std::ostringstream wout;
    std::ostringstream werr;
    int wc = tsfile_cli::run_cli(
        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "s1",
         "INT64", "-i", csv, "-o", out_path},
        wout, werr);
    EXPECT_EQ(wc, 0) << werr.str();
    EXPECT_TRUE(file_exists(out_path));

    std::ostringstream rout;
    std::ostringstream rerr;
    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", out_path},
                                  rout, rerr),
              0)
        << rerr.str();
    EXPECT_EQ(rout.str(), "time,id1,s1\n0,dev,0\n1,dev,10\n");

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, WriteMapsInputByHeaderName) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_header_order", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "temp,time,site\n21.5,1000,beijing\n22.0,2000,shanghai\n";
    }
    std::string out_path = tsfile_cli_test::unique_temp_path(
        "tsfile_cli_header_order_out", ".tsfile");

    std::ostringstream wout;
    std::ostringstream werr;
    int wc = tsfile_cli::run_cli(
        {"write", "--table", "sensors", "--tag", "site", "STRING", "--field",
         "temp", "FLOAT", "-i", csv, "-o", out_path},
        wout, werr);
    EXPECT_EQ(wc, 0) << werr.str();

    std::ostringstream rout;
    std::ostringstream rerr;
    EXPECT_EQ(tsfile_cli::run_cli(
                  {"cat", "-t", "sensors", "-f", "csv", out_path}, rout, rerr),
              0)
        << rerr.str();
    EXPECT_EQ(rout.str(),
              "time,site,temp\n1000,beijing,21.5\n2000,shanghai,22\n");

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, WriteRejectsHeaderShapeErrorsBeforeCreatingOutput) {
    struct Case {
        const char* name;
        const char* content;
        const char* needle;
    };
    const Case cases[] = {
        {"missing", "time,site\n1000,beijing\n", "missing required column"},
        {"undeclared", "time,site,temp,status\n1000,beijing,21.5,true\n",
         "undeclared column"},
        {"duplicate", "time,site,temp,TEMP\n1000,beijing,21.5,22.0\n",
         "conflict"},
    };
    for (const Case& c : cases) {
        std::string csv = tsfile_cli_test::unique_temp_path(
            std::string("tsfile_cli_header_") + c.name, ".csv");
        {
            std::ofstream o(csv.c_str());
            o << c.content;
        }
        std::string out_path = tsfile_cli_test::unique_temp_path(
            std::string("tsfile_cli_header_out_") + c.name, ".tsfile");

        std::ostringstream out;
        std::ostringstream err;
        int code = tsfile_cli::run_cli(
            {"write", "--table", "sensors", "--tag", "site", "STRING",
             "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
            out, err);
        EXPECT_EQ(code, 2) << c.name << " " << err.str();
        EXPECT_TRUE(out.str().empty());
        EXPECT_NE(err.str().find(c.needle), std::string::npos)
            << c.name << " " << err.str();
        EXPECT_FALSE(file_exists(out_path));

        std::remove(csv.c_str());
        std::remove(out_path.c_str());
    }
}

TEST(CliRequirements, WriteAppliesAndValidatesTypePhysicalOverrides) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_type_override", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "time,site,temp,humidity\n"
             "1000,beijing,21.0,40.5\n"
             "2000,beijing,21.5,41.0\n";
    }
    std::string out_path = tsfile_cli_test::unique_temp_path(
        "tsfile_cli_type_override_out", ".tsfile");

    std::ostringstream wout;
    std::ostringstream werr;
    int wc = tsfile_cli::run_cli(
        {"write",      "--table",      "sensors",  "--tag",
         "site",       "STRING",       "--field",  "temp",
         "FLOAT",      "--field",      "humidity", "FLOAT",
         "--encoding", "FLOAT",        "GORILLA",  "--compression",
         "FLOAT",      "UNCOMPRESSED", "-i",       csv,
         "-o",         out_path},
        wout, werr);
    EXPECT_EQ(wc, 0) << werr.str();

    std::ostringstream schema_out;
    std::ostringstream schema_err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"schema", "-t", "sensors", "-f", "csv", out_path},
                            schema_out, schema_err),
        0)
        << schema_err.str();
    EXPECT_NE(schema_out.str().find(
                  "table,sensors,temp,FIELD,FLOAT,GORILLA,UNCOMPRESSED\n"),
              std::string::npos)
        << schema_out.str();
    EXPECT_NE(schema_out.str().find(
                  "table,sensors,humidity,FIELD,FLOAT,GORILLA,UNCOMPRESSED\n"),
              std::string::npos)
        << schema_out.str();

    std::ostringstream dup_out;
    std::ostringstream dup_err;
    EXPECT_EQ(tsfile_cli::run_cli(
                  {"write", "--table", "sensors", "--field", "temp", "FLOAT",
                   "--encoding", "FLOAT", "GORILLA", "--encoding", "FLOAT",
                   "PLAIN", "--stdin", "-o", "unused.tsfile"},
                  dup_out, dup_err),
              1);
    EXPECT_NE(dup_err.str().find("specified more than once"), std::string::npos)
        << dup_err.str();

    std::ostringstream unused_out;
    std::ostringstream unused_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "sensors", "--field",
                                   "temp", "FLOAT", "--encoding", "DOUBLE",
                                   "GORILLA", "--stdin", "-o", "unused.tsfile"},
                                  unused_out, unused_err),
              1);
    EXPECT_NE(unused_err.str().find("not used"), std::string::npos)
        << unused_err.str();

    std::ostringstream bad_out;
    std::ostringstream bad_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "binary_data", "--field",
                                   "payload", "BLOB", "--encoding", "BLOB",
                                   "GORILLA", "--stdin", "-o", "unused.tsfile"},
                                  bad_out, bad_err),
              1);
    EXPECT_NE(bad_err.str().find("not supported"), std::string::npos)
        << bad_err.str();

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, WriteRejectsExistingOutputWithoutTruncating) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_existing_in", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "time,s1\n0,10\n";
    }
    std::string out_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_existing_out", ".tsfile");
    {
        std::ofstream o(out_path.c_str());
        o << "keep-me";
    }

    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                    "INT64", "-i", csv, "-o", out_path},
                                   out, err);
    EXPECT_EQ(code, 3);
    EXPECT_EQ(read_file(out_path), "keep-me");

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, WriteRejectsNonRegularInputBeforeCreatingOutput) {
#ifndef _WIN32
    std::string dir =
        tsfile_cli_test::unique_temp_path("tsfile_cli_input_dir", "");
    ASSERT_EQ(mkdir(dir.c_str(), 0777), 0);
    std::string out_path = tsfile_cli_test::unique_temp_path(
        "tsfile_cli_input_dir_out", ".tsfile");

    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                    "INT64", "-i", dir, "-o", out_path},
                                   out, err);
    EXPECT_EQ(code, 2);
    EXPECT_FALSE(file_exists(out_path));

    rmdir(dir.c_str());
#endif
}

TEST(CliRequirements, WriteRejectsNonCanonicalTimeLexemesAsInputErrors) {
    const char* bad_times[] = {"+1", "01", "-0"};
    for (const char* bad_time : bad_times) {
        std::string csv =
            tsfile_cli_test::unique_temp_path("tsfile_cli_bad_time", ".csv");
        {
            std::ofstream o(csv.c_str());
            o << "time,s1\n" << bad_time << ",10\n";
        }
        std::string out_path = tsfile_cli_test::unique_temp_path(
            "tsfile_cli_bad_time_out", ".tsfile");
        std::ostringstream out;
        std::ostringstream err;
        int code =
            tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                 "INT64", "-i", csv, "-o", out_path},
                                out, err);
        EXPECT_EQ(code, 2) << bad_time << " " << err.str();
        EXPECT_FALSE(file_exists(out_path)) << bad_time;
        std::remove(csv.c_str());
        std::remove(out_path.c_str());
    }
}

TEST(CliRequirements, WriteTargetFailuresAreRuntimeErrors) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_target", ".csv");
    {
        std::ofstream o(csv.c_str(), std::ios::binary);
        o << "time,s1\n0,1\n";
    }

    std::ostringstream same_out;
    std::ostringstream same_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                   "INT64", "-i", csv, "-o", csv},
                                  same_out, same_err),
              3);
    EXPECT_TRUE(same_out.str().empty());
    EXPECT_NE(same_err.str().find("same as the input"), std::string::npos)
        << same_err.str();
    EXPECT_EQ(read_file(csv), "time,s1\n0,1\n");

    std::string parent =
        tsfile_cli_test::unique_temp_path("tsfile_cli_missing_parent", "");
    std::string child = parent + "/out.tsfile";
    std::ostringstream parent_out;
    std::ostringstream parent_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                   "INT64", "-i", csv, "-o", child},
                                  parent_out, parent_err),
              3);
    EXPECT_TRUE(parent_out.str().empty());
    EXPECT_NE(parent_err.str().find("cannot create output"), std::string::npos)
        << parent_err.str();
    EXPECT_FALSE(file_exists(child));

    std::remove(csv.c_str());
}

TEST(CliRequirements, WriteCsvNullAndEmptyStringRemainDistinctTags) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_tag_null", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "time,site,temp\n1000,\\N,21.0\n1000,\"\",22.0\n";
    }
    std::string out_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_tag_null_out", ".tsfile");
    std::ostringstream out;
    std::ostringstream err;
    ASSERT_EQ(tsfile_cli::run_cli(
                  {"write", "--table", "sensors", "--tag", "site", "STRING",
                   "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
                  out, err),
              0)
        << err.str();

    std::ostringstream cat_out;
    std::ostringstream cat_err;
    ASSERT_EQ(
        tsfile_cli::run_cli({"cat", "-t", "sensors", "-f", "ndjson", out_path},
                            cat_out, cat_err),
        0)
        << cat_err.str();
    EXPECT_NE(cat_out.str().find("\"site\":null"), std::string::npos)
        << cat_out.str();
    EXPECT_NE(cat_out.str().find("\"site\":\"\""), std::string::npos)
        << cat_out.str();
    EXPECT_NE(cat_out.str().find("\"temp\":21"), std::string::npos)
        << cat_out.str();
    EXPECT_NE(cat_out.str().find("\"temp\":22"), std::string::npos)
        << cat_out.str();

    std::ostringstream count_out;
    std::ostringstream count_err;
    ASSERT_EQ(tsfile_cli::run_cli({"count", "-t", "sensors", "-m", "site", "-f",
                                   "csv", out_path},
                                  count_out, count_err),
              0)
        << count_err.str();
    EXPECT_NE(count_out.str().find("table,sensors,site,TAG,2,2"),
              std::string::npos)
        << count_out.str();

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, WriteRejectsUnterminatedQuotedCsvField) {
    std::string csv =
        tsfile_cli_test::unique_temp_path("tsfile_cli_unclosed_quote", ".csv");
    {
        std::ofstream o(csv.c_str());
        o << "time,site,temp\n1000,\"beijing,21.0\n";
    }
    std::string out_path = tsfile_cli_test::unique_temp_path(
        "tsfile_cli_unclosed_quote_out", ".tsfile");
    std::ostringstream out;
    std::ostringstream err;
    EXPECT_EQ(tsfile_cli::run_cli(
                  {"write", "--table", "sensors", "--tag", "site", "STRING",
                   "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
                  out, err),
              2);
    EXPECT_TRUE(out.str().empty());
    EXPECT_NE(err.str().find("unterminated quoted CSV field"),
              std::string::npos)
        << err.str();
    EXPECT_FALSE(file_exists(out_path));

    std::remove(csv.c_str());
    std::remove(out_path.c_str());
}

TEST(CliRequirements, LegacyColumnsOptionIsRejected) {
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"write", "--table", "t1", "--columns",
                                    "legacy", "-o", "x.tsfile", "--stdin"},
                                   out, err);
    EXPECT_EQ(code, 1);
    EXPECT_TRUE(out.str().empty());
    EXPECT_NE(err.str().find("Unknown flag: --columns"), std::string::npos)
        << err.str();
}

TEST(CliRequirements, WriteRejectsImplicitInputAndFormatFlag) {
    std::ostringstream implicit_out;
    std::ostringstream implicit_err;
    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
                                   "INT64", "-o", "x.tsfile", "in.csv"},
                                  implicit_out, implicit_err),
              1);
    EXPECT_NE(
        implicit_err.str().find("choose exactly one of --input or --stdin"),
        std::string::npos)
        << implicit_err.str();

    std::ostringstream format_out;
    std::ostringstream format_err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1", "INT64",
                             "-f", "csv", "--stdin", "-o", "x.tsfile"},
                            format_out, format_err),
        1);
    EXPECT_NE(format_err.str().find("--format is not valid"), std::string::npos)
        << format_err.str();
}

TEST(CliRequirements, ExportWritesSingleObjectAtomically) {
    TableFixture f;
    std::string out_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_export", ".csv");

    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"export", "-t", "table1", "-o", out_path,
                                    "--type", "csv", "-m", "s1", f.path},
                                   out, err);
    EXPECT_EQ(code, 0) << err.str();
    EXPECT_TRUE(out.str().empty());

    std::ostringstream cat_out;
    std::ostringstream cat_err;
    EXPECT_EQ(tsfile_cli::run_cli(
                  {"cat", "-t", "table1", "-m", "s1", "-f", "csv", f.path},
                  cat_out, cat_err),
              0)
        << cat_err.str();
    EXPECT_EQ(read_file(out_path), cat_out.str());

    std::remove(out_path.c_str());
}

#ifndef _WIN32
TEST(CliRequirements, ExportForceRejectsSymlinkAndSpecialTargets) {
    TableFixture f;
    std::string sentinel =
        tsfile_cli_test::unique_temp_path("tsfile_cli_export_sentinel", ".txt");
    std::string symlink_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_export_link", ".csv");
    {
        std::ofstream file(sentinel.c_str());
        file << "sentinel";
    }
    ASSERT_EQ(symlink(sentinel.c_str(), symlink_path.c_str()), 0);

    std::ostringstream link_out;
    std::ostringstream link_err;
    EXPECT_EQ(tsfile_cli::run_cli({"export", "-t", "table1", "-o", symlink_path,
                                   "--type", "csv", "--force", f.path},
                                  link_out, link_err),
              3);
    EXPECT_EQ(read_file(sentinel), "sentinel");

    std::string fifo_path =
        tsfile_cli_test::unique_temp_path("tsfile_cli_export_fifo", ".csv");
    ASSERT_EQ(mkfifo(fifo_path.c_str(), 0600), 0);
    std::ostringstream fifo_out;
    std::ostringstream fifo_err;
    EXPECT_EQ(tsfile_cli::run_cli({"export", "-t", "table1", "-o", fifo_path,
                                   "--type", "csv", "--force", f.path},
                                  fifo_out, fifo_err),
              3);

    std::remove(symlink_path.c_str());
    std::remove(sentinel.c_str());
    std::remove(fifo_path.c_str());
}
#endif

TEST(CliRequirements, ExportWritesMultiObjectManifestAndNumberedFiles) {
    MultiTableFixture f;
    std::string dir =
        tsfile_cli_test::unique_temp_path("tsfile_cli_multi_export", "");

    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli(
        {"export", "-t", "sensors_a", "-t", "sensors_b", "--output-dir", dir,
         "--type", "csv", "-m", "s1", f.path},
        out, err);
    EXPECT_EQ(code, 0) << err.str();
    EXPECT_TRUE(out.str().empty());
    EXPECT_EQ(read_file(dir + "/0001.csv"),
              "time,id1,s1\n0,sensors_a_tag,10\n");
    EXPECT_EQ(read_file(dir + "/0002.csv"),
              "time,id1,s1\n0,sensors_b_tag,20\n");
    std::string manifest = read_file(dir + "/_manifest.json");
    EXPECT_NE(manifest.find("\"complete\": true"), std::string::npos)
        << manifest;
    EXPECT_NE(manifest.find("\"file\":\"0001.csv\""), std::string::npos)
        << manifest;
    EXPECT_NE(manifest.find("\"object\":\"sensors_b\""), std::string::npos)
        << manifest;
    EXPECT_NE(manifest.find("\"rows\":\"1\""), std::string::npos) << manifest;

    std::remove((dir + "/0001.csv").c_str());
    std::remove((dir + "/0002.csv").c_str());
    std::remove((dir + "/_manifest.json").c_str());
#ifndef _WIN32
    rmdir(dir.c_str());
#endif
}

TEST(CliRequirements, MultipleTagFiltersRequireAndHonorTagMatch) {
    std::string path = tsfile_cli_test::write_tag_filter_fixture();
    std::ostringstream missing_out;
    std::ostringstream missing_err;
    EXPECT_EQ(tsfile_cli::run_cli(
                  {"cat", "-m", "s1", "--tag-filter", "id1", "eq", "dev_a",
                   "--tag-filter", "id1", "eq", "dev_c", "-f", "csv", path},
                  missing_out, missing_err),
              1);

    std::ostringstream out;
    std::ostringstream err;
    EXPECT_EQ(
        tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1", "eq",
                             "dev_a", "--tag-filter", "id1", "eq", "dev_c",
                             "--tag-match", "any", "-f", "csv", path},
                            out, err),
        0)
        << err.str();
    EXPECT_EQ(out.str(), "time,id1,s1\n0,dev_a,10\n3,dev_c,40\n");
    std::remove(path.c_str());
}

TEST(CliRequirements, SketchRejectsRegularResultFormat) {
    TableFixture f;
    std::ostringstream out;
    std::ostringstream err;
    int code = tsfile_cli::run_cli({"sketch", "-f", "csv", f.path}, out, err);
    EXPECT_EQ(code, 1);
    EXPECT_TRUE(out.str().empty());
    EXPECT_NE(err.str().find("sketch does not accept --format"),
              std::string::npos)
        << err.str();
}

TEST(CliRequirements, SketchWritesStdoutAndAtomicOutput) {
    TableFixture f;
    std::ostringstream stdout_out;
    std::ostringstream stdout_err;
    ASSERT_EQ(tsfile_cli::run_cli({"sketch", f.path}, stdout_out, stdout_err),
              0)
        << stdout_err.str();
    EXPECT_NE(stdout_out.str().find("TsFile Sketch"), std::string::npos)
        << stdout_out.str();
    EXPECT_NE(stdout_out.str().find("model: table"), std::string::npos)
        << stdout_out.str();

    std::string output =
        tsfile_cli_test::unique_temp_path("tsfile_cli_sketch", ".txt");
    std::ostringstream file_out;
    std::ostringstream file_err;
    ASSERT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, f.path}, file_out,
                                  file_err),
              0)
        << file_err.str();
    EXPECT_TRUE(file_out.str().empty());
    EXPECT_EQ(read_file(output), stdout_out.str());

    const std::string sentinel = "do not replace";
    {
        std::ofstream existing(output.c_str(), std::ios::binary);
        existing << sentinel;
    }
    std::ostringstream no_force_out;
    std::ostringstream no_force_err;
    EXPECT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, f.path},
                                  no_force_out, no_force_err),
              3);
    EXPECT_EQ(read_file(output), sentinel);

    std::ostringstream force_out;
    std::ostringstream force_err;
    ASSERT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, "--force", f.path},
                                  force_out, force_err),
              0)
        << force_err.str();
    EXPECT_EQ(read_file(output), stdout_out.str());

    const std::string source_before = read_file(f.path);
    std::ostringstream alias_out;
    std::ostringstream alias_err;
    EXPECT_EQ(tsfile_cli::run_cli({"sketch", "-o", f.path, "--force", f.path},
                                  alias_out, alias_err),
              3);
    EXPECT_EQ(read_file(f.path), source_before);
    std::remove(output.c_str());
}

TEST(CliRequirements, ModelDetectionPrefersTableSchemaAndFallsBackToTree) {
    TableFixture table;
    storage::TsFileReader table_reader;
    ASSERT_EQ(table_reader.open(table.path), common::E_OK);
    EXPECT_FALSE(table_reader.get_all_table_schemas().empty());
    EXPECT_FALSE(table_reader.get_all_device_ids().empty());
    table_reader.close();

    std::ostringstream table_out;
    std::ostringstream table_err;
    ASSERT_EQ(tsfile_cli::run_cli({"ls", "-f", "csv", table.path}, table_out,
                                  table_err),
              0)
        << table_err.str();
    EXPECT_EQ(table_out.str(), "model,object\ntable,table1\n");

    std::string tree_path = tsfile_cli_test::write_sparse_tree_fixture();
    storage::TsFileReader tree_reader;
    ASSERT_EQ(tree_reader.open(tree_path), common::E_OK);
    EXPECT_TRUE(tree_reader.get_all_table_schemas().empty());
    EXPECT_FALSE(tree_reader.get_all_device_ids().empty());
    tree_reader.close();

    std::ostringstream tree_out;
    std::ostringstream tree_err;
    ASSERT_EQ(
        tsfile_cli::run_cli({"ls", "-f", "csv", tree_path}, tree_out, tree_err),
        0)
        << tree_err.str();
    EXPECT_EQ(tree_out.str(), "model,object\ntree,root.test.d1\n");
    std::remove(tree_path.c_str());
}