#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>

// Node representing a user in the linked list
class User {
public:
    std::string name;
    int age;
    std::string gender;
    std::string phone;
    std::string profession;
    std::string school;
    double latitude;
    double longitude;
    bool premium;
    int prefMinAge;
    int prefMaxAge;
    int maxDistance;
    std::string prefGender;
    std::vector<std::string> likes; // list of phone numbers this user liked
    User* next;
};

// Helper function to convert underscores to spaces in a string
std::string formatString(const std::string &s) {
    std::string result = "";
    for (std::size_t i = 0; i < s.size(); i++) {
        if (s[i] == '_')
            result.push_back(' ');
        else
            result.push_back(s[i]);
    }
    return result;
}

// Calculate the distance between two coordinates using the Haversine formula
double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
    const double radiusOfEarth = 6371.0; // Earth's radius in kilometers

    // Convert degrees to radians
    lat1 = lat1 * M_PI / 180.0;
    lon1 = lon1 * M_PI / 180.0;
    lat2 = lat2 * M_PI / 180.0;
    lon2 = lon2 * M_PI / 180.0;

    double dLat = lat2 - lat1;
    double dLon = lon2 - lon1;
    double a = sin(dLat / 2.0) * sin(dLat / 2.0) +
               cos(lat1) * cos(lat2) *
               sin(dLon / 2.0) * sin(dLon / 2.0);
    double c = 2.0 * atan2(sqrt(a), sqrt(1.0 - a));
    double distanceKM = radiusOfEarth * c;
    double distanceMiles = distanceKM * 0.621371;
    return distanceMiles;
}

// Splits a string by the underscore delimiter
std::vector<std::string> splitLikes(const std::string &s) {
    std::vector<std::string> result;
    std::istringstream iss(s);
    std::string token;
    while (std::getline(iss, token, '_')) {
        result.push_back(token);
    }
    return result;
}

// Loads the users from the given file and returns the head of the linked list
User* loadUsers(const std::string &filename) {
    std::ifstream fin(filename.c_str());
    if (!fin) {
        std::cerr << "Error opening file: " << filename << std::endl;
        return 0;
    }
    User* head = 0;
    User* tail = 0;
    std::string line;
    while (std::getline(fin, line)) {
        if (line.empty())
            continue;
        std::istringstream iss(line);
        User* newUser = new User;
        newUser->next = 0;
        std::string premiumStr, likesStr;
        // Read the 14 fields
        iss >> newUser->name 
            >> newUser->age 
            >> newUser->gender 
            >> newUser->phone 
            >> newUser->profession 
            >> newUser->school 
            >> newUser->latitude 
            >> newUser->longitude 
            >> premiumStr 
            >> newUser->prefMinAge 
            >> newUser->prefMaxAge 
            >> newUser->maxDistance 
            >> newUser->prefGender 
            >> likesStr;
        // Convert premium field
        newUser->premium = (premiumStr == "true");
        // Process likes: if "null", then empty; else split by underscore
        if (likesStr != "null") {
            newUser->likes = splitLikes(likesStr);
        }
        // Append to linked list
        if (head == 0) {
            head = newUser;
            tail = newUser;
        } else {
            tail->next = newUser;
            tail = newUser;
        }
    }
    fin.close();
    return head;
}

// Frees the memory allocated for the linked list
void freeUsers(User* head) {
    while (head) {
        User* temp = head;
        head = head->next;
        delete temp;
    }
}

// Finds and returns the pointer to the user with the given phone number
User* findUser(User* head, const std::string &phone) {
    User* curr = head;
    while (curr) {
        if (curr->phone == phone)
            return curr;
        curr = curr->next;
    }
    return 0;
}

// Checks whether a given phone number exists in the likes vector of a user
bool isNumberInLikes(const User* user, const std::string &phone) {
    std::vector<std::string>::const_iterator it;
    for (it = user->likes.begin(); it != user->likes.end(); ++it) {
        if (*it == phone)
            return true;
    }
    return false;
}

// Removes the given phone number from the user's likes vector
void removeLike(User* user, const std::string &phone) {
    std::vector<std::string>::iterator it;
    for (it = user->likes.begin(); it != user->likes.end(); ++it) {
        if (*it == phone) {
            user->likes.erase(it);
            break;
        }
    }
}

// Checks whether candidate matches the current user's preference
bool matchesPreference(const User* current, const User* candidate) {
    // Exclude self
    if (current->phone == candidate->phone)
        return false;
    // Check age
    if (candidate->age < current->prefMinAge || candidate->age > current->prefMaxAge)
        return false;
    // Check gender preference
    if (current->prefGender != "Both" && candidate->gender != current->prefGender)
        return false;
    // Check distance
    double dist = calculateDistance(current->latitude, current->longitude, candidate->latitude, candidate->longitude);
    if (dist > current->maxDistance)
        return false;
    return true;
}

// Prints a single profile to the output stream
void printProfile(std::ofstream &out, const User* user) {
    out << user->name << " " << user->age;
    if (user->profession != "Undisclosed")
        out << std::endl << formatString(user->profession);
    if (user->school != "Undisclosed")
        out << std::endl << formatString(user->school);
    out << std::endl;
}

// Returns a vector of users who match the current user's preference
// If excludePhone is nonempty, then any user with that phone is skipped
std::vector<User*> getMatchingProfiles(const User* current, const User* head, const std::string &excludePhone = "") {
    std::vector<User*> result;
    const User* curr = head;
    while (curr) {
        if (excludePhone != "" && curr->phone == excludePhone) {
            curr = curr->next;
            continue;
        }
        if (matchesPreference(current, curr))
            result.push_back(const_cast<User*>(curr));
        curr = curr->next;
    }
    return result;
}

// Returns a vector of users who mutually match with the current user
// A mutual match is defined as current liking candidate and candidate liking current
std::vector<User*> getMatches(const User* current, const User* head) {
    std::vector<User*> result;
    const User* curr = head;
    while (curr) {
        if (current->phone == curr->phone) {
            curr = curr->next;
            continue;
        }
        if (isNumberInLikes(current, curr->phone) && isNumberInLikes(curr, current->phone))
            result.push_back(const_cast<User*>(curr));
        curr = curr->next;
    }
    return result;
}

// Returns a vector of users who liked the current user
std::vector<User*> getLikes(const User* current, const User* head) {
    std::vector<User*> result;
    const User* curr = head;
    while (curr) {
        if (current->phone == curr->phone) {
            curr = curr->next;
            continue;
        }
        if (isNumberInLikes(curr, current->phone))
            result.push_back(const_cast<User*>(curr));
        curr = curr->next;
    }
    return result;
}

// Command: show profiles (or for block command, with an exclusion)
void commandShowProfiles(const User* current, const User* head, std::ofstream &out, const std::string &excludePhone = "") {
    std::vector<User*> profiles = getMatchingProfiles(current, head, excludePhone);
    if (profiles.empty()) {
        out << "There are no users matching with your preference at this moment." << std::endl;
        return;
    }
    const User* curr = head;
    bool first = true;
    while (curr) {
        if ((excludePhone == "" || curr->phone != excludePhone) && matchesPreference(current, curr)) {
            if (!first) out << std::endl;
            printProfile(out, curr);
            first = false;
        }
        curr = curr->next;
    }
}

// Command: show matches. Matches should be sorted by phone (increasing order)
void commandShowMatches(const User* current, const User* head, std::ofstream &out) {
    std::vector<User*> matches = getMatches(current, head);
    if (matches.empty()) {
        out << "You do not have any matches at this moment.";
        return;
    }
    std::sort(matches.begin(), matches.end(), 
        [](User* a, User* b) -> bool { return a->phone < b->phone; });
    for (size_t i = 0; i < matches.size(); ++i) {
        if (i > 0) out << std::endl;
        printProfile(out, matches[i]);
    }
}

// Command: show likes. Only premium users can use this
void commandShowLikes(const User* current, const User* head, std::ofstream &out) {
    if (!current->premium) {
        out << "Only premium users can view who liked you.";
        return;
    }
    std::vector<User*> likes = getLikes(current, head);
    if (likes.empty()) {
        out << "You have not received any likes so far.";
        return;
    }
    const User* curr = head;
    bool first = true;
    while (curr) {
        if (current->phone != curr->phone && isNumberInLikes(curr, current->phone)) {
            if (!first) out << std::endl;
            printProfile(out, curr);
            first = false;
        }
        curr = curr->next;
    }
}

// Command: unmatch someone. Remove mutual like between current and other,
// then print both users' match lists (sorted by phone number)
void commandUnmatch(User* current, User* other, const User* head, std::ofstream &out) {
    removeLike(current, other->phone);
    removeLike(other, current->phone);
    std::vector<User*> currentMatches = getMatches(current, head);
    std::vector<User*> otherMatches = getMatches(other, head);
    std::sort(currentMatches.begin(), currentMatches.end(), 
        [](User* a, User* b) -> bool { return a->phone < b->phone; });
    std::sort(otherMatches.begin(), otherMatches.end(), 
        [](User* a, User* b) -> bool { return a->phone < b->phone; });

    out << current->name << "'s match list:" << std::endl << std::endl;
    if (currentMatches.empty()) {
        out << "You do not have any matches at this moment." << std::endl;
    } else {
        for (size_t i = 0; i < currentMatches.size(); ++i) {
            if (i > 0) out << std::endl;
            printProfile(out, currentMatches[i]);
        }
    }
    out << std::endl << "======" << std::endl << std::endl;
    out << other->name << "'s match list:" << std::endl << std::endl;
    if (otherMatches.empty()) {
        out << "You do not have any matches at this moment." << std::endl;
    } else {
        for (size_t i = 0; i < otherMatches.size(); ++i) {
            if (i > 0) out << std::endl;
            printProfile(out, otherMatches[i]);
        }
    }
}

// Command: block someone. For the current user and the other user, print profiles
// that match their preference but exclude the blocked user
void commandBlock(const User* current, const User* other, const User* head, std::ofstream &out) {
    out << "profiles shown to " << current->name << ":" << std::endl << std::endl;
    commandShowProfiles(current, head, out, other->phone);
    out << std::endl << "======" << std::endl << std::endl;
    out << "profiles shown to " << other->name << ":" << std::endl << std::endl;
    commandShowProfiles(other, head, out, current->phone);
}

int main(int argc, char* argv[]) {
    if (argc < 5) {
        std::cerr << "Usage: nydate.exe users.txt output.txt phoneNumber command [phoneNumberOther]" << std::endl;
        return 1;
    }
    
    std::string usersFile = argv[1];
    std::string outputFile = argv[2];
    std::string currentPhone = argv[3];
    std::string command = argv[4];
    
    User* head = loadUsers(usersFile);
    if (head == 0) {
        return 1;
    }
    
    User* currentUser = findUser(head, currentPhone);
    if (currentUser == 0) {
        std::cerr << "User with phone " << currentPhone << " not found." << std::endl;
        freeUsers(head);
        return 1;
    }
    
    std::ofstream fout(outputFile.c_str());
    if (!fout) {
        std::cerr << "Error opening output file: " << outputFile << std::endl;
        freeUsers(head);
        return 1;
    }
    
    // Process commands
    if (command == "profile") {
        commandShowProfiles(currentUser, head, fout);
    } else if (command == "match") {
        commandShowMatches(currentUser, head, fout);
    } else if (command == "like") {
        commandShowLikes(currentUser, head, fout);
    } else if (command == "unmatch") {
        if (argc < 6) {
            std::cerr << "unmatch command requires a second phone number." << std::endl;
            freeUsers(head);
            return 1;
        }
        std::string otherPhone = argv[5];
        User* otherUser = findUser(head, otherPhone);
        if (otherUser == 0) {
            std::cerr << "User with phone " << otherPhone << " not found." << std::endl;
            freeUsers(head);
            return 1;
        }
        commandUnmatch(currentUser, otherUser, head, fout);
    } else if (command == "block") {
        if (argc < 6) {
            std::cerr << "block command requires a second phone number." << std::endl;
            freeUsers(head);
            return 1;
        }
        std::string otherPhone = argv[5];
        User* otherUser = findUser(head, otherPhone);
        if (otherUser == 0) {
            std::cerr << "User with phone " << otherPhone << " not found." << std::endl;
            freeUsers(head);
            return 1;
        }
        commandBlock(currentUser, otherUser, head, fout);
    } else {
        std::cerr << "Unknown command: " << command << std::endl;
    }
    
    fout.close();
    freeUsers(head);
    return 0;
}