#pragma once

#include <string>
#include <vector>
#include <unordered_map>
#include <queue>

using ll = long long;

class Gate {
public:
    int id;
    std::string name;
    enum Type { AND, NAND, OR, NOR, XOR, XNOR, NOT, BUF, INPUT } type;
    int value;
    bool sa[2];
    bool stem;
    bool isPI;
    bool isPO;

    std::unordered_map<Gate*, std::pair<int, int>> sa_by_out;

    std::vector<Gate*> pre_stems;

    std::vector<Gate*> block;

    std::vector<Gate*> outputs;
    std::vector<Gate*> inputs;

    bool is_propagated();
    int cal_value();
};

class Fault {
public:
    Gate* gate;
    enum Type { SA0, SA1 } type;
    Fault(Gate* gate, Type type):gate(gate),type(type) {}
};

class Circuit {
public:
std::vector<Gate*> PIs;
std::vector<Gate*> POs;
std::vector<Gate*> gates;
std::vector<Gate*> stems; // PI + stems

std::unordered_map<std::string, Gate*> name2gate;

std::queue<Gate*> tmp;
std::unordered_map<Gate*, bool> tmp_used;

void parse_from_file(const char *filename);
void print_gates();

bool is_valid_circuit();

void init_topo_index();
void init_stems();

// local search

std::vector<int> local_search(const std::vector<Fault*> &faults);

// incremental flip struct
ll flip_total_weight;
int* flip_weight;
int* flip_need_update;
std::vector<Gate*> flip_update_queue;

// incremental stem struct
ll stem_total_weight;
int* stem_weight;
int* stem_satisfied;

ll fault_total_weight;
int** fault_weight;
int** fault_detected;

void ls_init_circuit();
void ls_init_weight(const std::vector<Fault*> &faults);
void ls_init_data_structs();

void ls_block_recal(Gate* stem);

void ls_flip(Gate* stem);
void ls_update(Gate* stem);
int ls_score(Gate* stem);
};