frontend/src/result.ts

// import {call_api} from "@/api";

import {Zone} from "@/zone";
import type {Message} from "@/utils";
import type {Collection} from "@/collection";
import {call_api} from "@/api";

// let ex_collection = () => new Collection("example.ton", "Example collection");

export class Result {
    domain: string;
    buy_price?: number;
    auction_price?: number;
    owner?: string;
    collection_required: Collection | null;
    condition_fulfilled: boolean | null = null;
    buy_msg: Message | null = null;
    content_msg: Message | null = null;
    nft_info?: any;

    constructor(domain: string, buy_price?: number, auction_price?: number, owner?: string, collection_required: Collection | null = null, condition_fulfilled: boolean | null = null, buy_msg: Message | null = null, content_msg: Message | null = null, nft_info?: any) {
        this.domain = domain;
        this.buy_price = buy_price;
        this.auction_price = auction_price;
        this.owner = owner;
        this.collection_required = collection_required;
        this.condition_fulfilled = condition_fulfilled;
        this.buy_msg = buy_msg;
        this.content_msg = content_msg;
        this.nft_info = nft_info;
    }

    static fromBackend(data: any): Result {
        let domain = data.domain;
        let buy_price = data.buy_price;
        let auction_price = data.auction_price;
        let owner = data.owner;
        let collection_required = data.collection_required;
        let condition_fulfilled = data.condition_fulfilled;
        let buy_msg = data.buy_msg;
        let content_msg = data.content_msg;
        let nft_info = data.nft_info;

        return new Result(domain, buy_price, auction_price, owner, collection_required, condition_fulfilled, buy_msg, content_msg, nft_info);
    }

    getRouteParams(): any {
        return {
            domain_init: /* domain up to . */ this.domain.split('.')[0],
            domain: /* domain up to . */ this.domain.split('.')[0],
            zone: /* domain after . */ this.domain.split('.').slice(1).join('.')
        }
    }

    canAuction(): boolean {
        return this.auction_price !== undefined && this.auction_price !== null && this.owner === undefined;
    }

    canBuy(): boolean {
        return this.buy_price !== undefined && this.buy_price !== null && this.owner === undefined;
    }

    zone(): string {
        return this.domain.split('.').slice(1).join('.');
    }
}

// const sleep = (milliseconds: number) => {
//     return new Promise(resolve => setTimeout(resolve, milliseconds))
// }

export async function get_search_results(query: string) {
    return Result.fromBackend(await call_api('find/' + query));
    /*await sleep(200);
    return [
        new Result(query + '.ton', 5, 3),
        new Result(query + '.ton', 1),
        new Result(query + '.ton', undefined, 2),
        new Result(query + '.ton', undefined, undefined, '123')
    ];*/
}

export async function get_domain_result(domain: string, _address?: string) {
    return Result.fromBackend(await call_api('get/' + domain));
    /*await sleep(100);
    if (domain === 'test.ton') {
        return new Result(domain);
    }
    let exc = ex_collection();
    if (domain.startsWith('owned')) {
        return new Result(domain, 5, 3, '123');
    }
    if (parse_zone(domain) === 'example.ton') {
        return new Result(domain, 5, 3, undefined, exc);
    }
    if (parse_zone(domain) === 'testtesttest.ton') {
        console.log(address)
        if (address !== undefined && address !== '') {
            return new Result(domain, 5, 3, undefined, exc, false);
        } else {
            return new Result(domain, 5, 3, undefined, exc);
        }
    }
    return new Result(domain, 5, 3);*/
}

export async function get_records(address: string) {
    return await call_api('records/' + address);
}

export async function get_zones() {
    let zones_back = await call_api('zones');
    return zones_back.map((zone: any) => new Zone(zone.zone, zone.price_buy_1, zone.price_buy_2, zone.collection_required, zone.price_auction_1, zone.price_auction_2, zone.min_length, zone.length_1, zone.length_2, zone.address));
    /*await sleep(10);
    return [
        new Zone("example.ton", 3, 5, ex_collection()),
        new Zone("agorata.ton", 3, 5),
        new Zone("testtesttest.ton", 1, 1, ex_collection())];*/
}

export class TonLink {
    address: string;
    sum?: number;
    message: string;

    constructor(address: string, message: string, sum?: number) {
        this.address = address;
        this.sum = sum;
        this.message = message;
    }

    getLink(): string {
        // todo: use tonapi to run dnsresolve on the address (or move the task to the backend) - domains don't work well in links
        let link = `ton://transfer/${this.address}?message=${this.message}`;
        if (this.sum !== undefined) {
            link += `&amount=${this.sum}`;
        }
        return link;
    }
}

// Get the link for buying a domain
export function get_ton_link(res: Result) {
    return new TonLink(res.zone(), 'b/' + res.domain, res.buy_price!);
}

export let link_types = ['telegram', 'website', 'getgems', 'email'];
export let link_icons = {'telegram': 'fab fa-telegram', 'website': 'material-icons language', 'getgems': 'fas fa-gem', 'email': 'fas fa-envelope'};
export let default_links = {'telegram': 'https://t.me/', 'website': 'https://', 'getgems': 'https://getgems.org/', 'email': 'example@example.org'};

export class SiteConstructorParams {
    domain: string;
    title: string;
    description: string;
    contacts: Map<string, string> = new Map<string, string>();

    constructor(domain: string, title: string = '', description: string = '', contacts: Map<string, string> = new Map<string, string>()) {
        this.domain = domain;
        this.title = title;
        this.description = description;
        this.contacts = contacts;
    }

    copy(): SiteConstructorParams {
        return new SiteConstructorParams(this.domain, this.title);
    }
}

export async function get_constr_params(domain: string) {
    let res = await call_api('get-site-data/' + domain);
    return new SiteConstructorParams(res.domain, res.title, res.description, res.contacts);
}