/*
 * 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.
 */

#ifndef THRIFT_TEST_FUZZ_COMMON_TCC_
#define THRIFT_TEST_FUZZ_COMMON_TCC_

#include <stddef.h>
#include <stdint.h>
#include <memory>
#include <cmath>
#include <iostream>

#include <thrift/protocol/TDebugProtocol.h>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/TToString.h>
#include <thrift/TConfiguration.h>

#include "gen-cpp/FuzzTest_types.h"

namespace apache { namespace thrift { namespace fuzzer {

using namespace apache::thrift::transport;
using namespace apache::thrift::protocol;
using namespace fuzz;

// 10MB message size limit to prevent over-allocation during fuzzing
const int FUZZ_MAX_MESSAGE_SIZE = 10 * 1024 * 1024;

inline bool is_nan_false_positive(FuzzTest& test1, FuzzTest& test2) {
  BasicTypes& b1 = test1.basic;
  BasicTypes& b2 = test2.basic;
  if (std::isnan(b1.double_field) && std::isnan(b2.double_field)) {
    b1.double_field = 0.0;
    b2.double_field = 0.0;
  }

  // Check for NaN in containers if they contain doubles
  // This is a simplified version - may need adjustment based on actual schema
  
  return test1 == test2;
}

// Simple parse-only fuzzer
template<typename ProtocolType>
int fuzz_parse(const uint8_t* data, size_t size) {
  try {
    std::shared_ptr<TConfiguration> config(new TConfiguration(FUZZ_MAX_MESSAGE_SIZE));
    std::shared_ptr<TMemoryBuffer> trans(new TMemoryBuffer(const_cast<uint8_t*>(data), size, TMemoryBuffer::OBSERVE, config));
    std::shared_ptr<TProtocol> proto(new ProtocolType(trans));

    FuzzTest test;
    test.read(proto.get());
  } catch (const TException&) {
    // Ignore any Thrift exceptions - they're expected when fuzzing
  }
  return 0;
}

// Roundtrip fuzzer that verifies serialization/deserialization
template<typename ProtocolType>
int fuzz_roundtrip(const uint8_t* data, size_t size) {
  try {
    std::shared_ptr<TConfiguration> config(new TConfiguration(FUZZ_MAX_MESSAGE_SIZE));
    
    // First parse
    std::shared_ptr<TMemoryBuffer> trans(new TMemoryBuffer(const_cast<uint8_t*>(data), size, TMemoryBuffer::OBSERVE, config));
    std::shared_ptr<TProtocol> proto(new ProtocolType(trans));

    FuzzTest test1;
    test1.read(proto.get());

    // Serialize back
    std::shared_ptr<TMemoryBuffer> outTrans(new TMemoryBuffer(config));
    std::shared_ptr<TProtocol> outProto(new ProtocolType(outTrans));
    test1.write(outProto.get());

    // Get serialized data
    std::string serialized = outTrans->getBufferAsString();

    // Deserialize again
    std::shared_ptr<TMemoryBuffer> reTrans(new TMemoryBuffer(config));
    reTrans->write((const uint8_t*)serialized.data(), static_cast<uint32_t>(serialized.size()));
    std::shared_ptr<TProtocol> reProto(new ProtocolType(reTrans));

    FuzzTest test2;
    test2.read(reProto.get());

    // Verify equality
    if (!(test1 == test2) && !is_nan_false_positive(test1, test2)) {
      const std::string str1(apache::thrift::ThriftDebugString(test1));
      const std::string str2(apache::thrift::ThriftDebugString(test2));

      std::cout << "Expected:\n" << str1 << "\nGotten:\n" << str2 << std::endl;

      throw std::runtime_error("Roundtrip failed");
    }
  } catch (const TException&) {
    // Ignore any Thrift exceptions - they're expected when fuzzing
  }
  return 0;
}

}}} // apache::thrift::fuzzer

#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
__attribute__((weak)) int main(int argc, char** argv) {
  return 0;
}
#endif 

#endif // THRIFT_TEST_FUZZ_COMMON_TCC_