/*   SHS: Syntactically Homogeneous Shell
 *   Copyright (C) 2019  Aidan Hahn
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package stdlib

import (
    "strconv"
    "gitlab.com/whom/shs/log"
    "gitlab.com/whom/shs/ast"
)

// lt, gt

func not(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    if in.Tag != ast.BOOL {
        log.Log(log.ERR, "non-bool argument to 'not'", "not")
        return nil
    }

    out := "T"
    if in.Inner.(string) == "T" {
        out = "F"
    }

    return &ast.Token{Tag: ast.BOOL, Inner: out}
}

func eq(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    out := "T"
    second := in.Next

    if in.Tag != second.Tag {
        out = "F"
    } else {
        switch in.Tag {
        case ast.LIST:
            // returns true if difference found
            var consume_list func(*ast.Token, *ast.Token) bool
            consume_list = func(l *ast.Token, r *ast.Token) bool {
                if (l == nil && r != nil) || (r == nil && l != nil) {
                    return true
                }

                if l.Tag != r.Tag {
                    return true
                }

                l_iter := l
                r_iter := r
                for l_iter != nil {
                    if r_iter == nil || l_iter.Tag != r_iter.Tag {
                        return true
                    }

                    if l_iter.Tag == ast.LIST {
                        diff := consume_list(l_iter.Inner.(*ast.Token),
                                     r_iter.Inner.(*ast.Token))
                        if diff {
                            return true
                        } 

                    } else {
                        if l_iter.Inner.(string) != r_iter.Inner.(string) {
                            return true
                        }
                    }

                    l_iter = l_iter.Next
                    r_iter = r_iter.Next
                }

                if r_iter != nil {
                    return true
                } else {
                    return false
                }
            }

            if consume_list(in.Inner.(*ast.Token), second.Inner.(*ast.Token)) {
                out = "F"
            }

        case ast.NUMBER, ast.STRING, ast.BOOL:
            if in.Inner.(string) != second.Inner.(string) {
                out = "F"
            }
        }
    }

    return &ast.Token{Tag: ast.BOOL, Inner: out}
}

func lt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    out := "T"

    second := in.Next
    if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER {
        log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=")
        return nil
    }

    l, _ := strconv.ParseInt(in.Inner.(string), 10, 64)
    r, _ := strconv.ParseInt(second.Inner.(string), 10, 64)

    if l >= r {
        out = "F"
    }

    return &ast.Token{Tag: ast.BOOL, Inner: out}
}

func gt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    out := "T"

    second := in.Next
    if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER {
        log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=")
        return nil
    }

    l, _ := strconv.ParseInt(in.Inner.(string), 10, 64)
    r, _ := strconv.ParseInt(second.Inner.(string), 10, 64)

    if l <= r {
        out = "F"
    }

    return &ast.Token{Tag: ast.BOOL, Inner: out}
}

func ne(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    return not(eq(in, vt, ft), vt, ft)
}

func gte(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    return not(lt(in, vt, ft), vt, ft)
}

func lte(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
    return not(gt(in, vt, ft), vt, ft)
}